• Re: Proving that P(P) != the correct x86 emulation of the input to H(P,

    From olcott@21:1/5 to Richard Damon on Thu Jun 9 11:54:13 2022
    XPost: comp.theory, sci.logic, sci.math

    On 6/9/2022 11:34 AM, Richard Damon wrote:
    On 6/9/22 11:47 AM, olcott wrote:
    void P(u32 x)
    {
       if (H(x, x))
         HERE: goto HERE;
       return;
    }

    int main()
    {
       P(P);
    }

    _P()
    [000012e7](01)  55              push ebp
    [000012e8](02)  8bec            mov ebp,esp
    [000012ea](03)  8b4508          mov eax,[ebp+08]
    [000012ed](01)  50              push eax
    [000012ee](03)  8b4d08          mov ecx,[ebp+08]
    [000012f1](01)  51              push ecx
    [000012f2](05)  e880feffff      call 00001177 // call H
    [000012f7](03)  83c408          add esp,+08
    [000012fa](02)  85c0            test eax,eax
    [000012fc](02)  7402            jz 00001300
    [000012fe](02)  ebfe            jmp 000012fe
    [00001300](01)  5d              pop ebp
    [00001301](01)  c3              ret
    Size in bytes:(0027) [00001301]

    _main()
    [00001307](01)  55              push ebp
    [00001308](02)  8bec            mov ebp,esp
    [0000130a](05)  68e7120000      push 000012e7 // push P
    [0000130f](05)  e8d3ffffff      call 000012e7 // call P
    [00001314](03)  83c404          add esp,+04
    [00001317](02)  33c0            xor eax,eax
    [00001319](01)  5d              pop ebp
    [0000131a](01)  c3              ret
    Size in bytes:(0020) [0000131a]

      machine   stack     stack     machine    assembly
      address   address   data      code       language
      ========  ========  ========  =========  =============
    [00001307][00102190][00000000] 55         push ebp
    [00001308][00102190][00000000] 8bec       mov ebp,esp
    [0000130a][0010218c][000012e7] 68e7120000 push 000012e7 // push P
    [0000130f][00102188][00001314] e8d3ffffff call 000012e7 // call P
    [000012e7][00102184][00102190] 55         push ebp      // enter
    executed P
    [000012e8][00102184][00102190] 8bec       mov ebp,esp
    [000012ea][00102184][00102190] 8b4508     mov eax,[ebp+08]
    [000012ed][00102180][000012e7] 50         push eax      // push P
    [000012ee][00102180][000012e7] 8b4d08     mov ecx,[ebp+08]
    [000012f1][0010217c][000012e7] 51         push ecx      // push P
    [000012f2][00102178][000012f7] e880feffff call 00001177 // call H

    Begin Local Halt Decider Simulation   Execution Trace Stored at:212244
    [000012e7][00212230][00212234] 55          push ebp      // enter
    emulated P
    [000012e8][00212230][00212234] 8bec        mov ebp,esp
    [000012ea][00212230][00212234] 8b4508      mov eax,[ebp+08]
    [000012ed][0021222c][000012e7] 50          push eax      // push P
    [000012ee][0021222c][000012e7] 8b4d08      mov ecx,[ebp+08]
    [000012f1][00212228][000012e7] 51          push ecx      // push P
    [000012f2][00212224][000012f7] e880feffff  call 00001177 // call H

    So, by what instruction reference manual is a call 00001177 followedby
    the execution of the instruction at 000012e7.

    Your "CPU" is broken, or emulation incorrect.

    FAIL.

    [000012e7][0025cc58][0025cc5c] 55          push ebp      // enter
    emulated P
    [000012e8][0025cc58][0025cc5c] 8bec        mov ebp,esp
    [000012ea][0025cc58][0025cc5c] 8b4508      mov eax,[ebp+08]
    [000012ed][0025cc54][000012e7] 50          push eax      // push P
    [000012ee][0025cc54][000012e7] 8b4d08      mov ecx,[ebp+08]
    [000012f1][0025cc50][000012e7] 51          push ecx      // push P
    [000012f2][0025cc4c][000012f7] e880feffff  call 00001177 // call H
    Local Halt Decider: Infinite Recursion Detected Simulation Stopped

    It is completely obvious that when H(P,P) correctly emulates its input
    that it must emulate the first seven instructions of P. Because the
    seventh instruction of P repeats this process we know with complete
    certainty that the correct and complete emulation of P by H would
    never reach its final “ret” instruction, thus never halts.

    Problem, the 7th intruction DOESN't "Just repeat the procedure", because
    that H always has the option to abort its simulation, just like this
    onne did, and return to its P and see it halt.

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO ACTUAL REBUTTAL
    AT ALL:

    The partial correct x86 emulation of the input to H(P,P) conclusively
    proves that the complete and correct x86 emulation would never stop
    running.


    --
    Copyright 2022 Pete Olcott

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

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Thu Jun 9 12:34:15 2022
    XPost: comp.theory, sci.logic, sci.math

    On 6/9/22 11:47 AM, olcott wrote:
    void P(u32 x)
    {
      if (H(x, x))
        HERE: goto HERE;
      return;
    }

    int main()
    {
      P(P);
    }

    _P()
    [000012e7](01)  55              push ebp
    [000012e8](02)  8bec            mov ebp,esp
    [000012ea](03)  8b4508          mov eax,[ebp+08]
    [000012ed](01)  50              push eax
    [000012ee](03)  8b4d08          mov ecx,[ebp+08]
    [000012f1](01)  51              push ecx
    [000012f2](05)  e880feffff      call 00001177 // call H [000012f7](03)  83c408          add esp,+08
    [000012fa](02)  85c0            test eax,eax
    [000012fc](02)  7402            jz 00001300
    [000012fe](02)  ebfe            jmp 000012fe
    [00001300](01)  5d              pop ebp
    [00001301](01)  c3              ret
    Size in bytes:(0027) [00001301]

    _main()
    [00001307](01)  55              push ebp
    [00001308](02)  8bec            mov ebp,esp
    [0000130a](05)  68e7120000      push 000012e7 // push P [0000130f](05)  e8d3ffffff      call 000012e7 // call P [00001314](03)  83c404          add esp,+04
    [00001317](02)  33c0            xor eax,eax
    [00001319](01)  5d              pop ebp
    [0000131a](01)  c3              ret
    Size in bytes:(0020) [0000131a]

     machine   stack     stack     machine    assembly
     address   address   data      code       language
     ========  ========  ========  =========  ============= [00001307][00102190][00000000] 55         push ebp [00001308][00102190][00000000] 8bec       mov ebp,esp [0000130a][0010218c][000012e7] 68e7120000 push 000012e7 // push P [0000130f][00102188][00001314] e8d3ffffff call 000012e7 // call P [000012e7][00102184][00102190] 55         push ebp      // enter executed P
    [000012e8][00102184][00102190] 8bec       mov ebp,esp [000012ea][00102184][00102190] 8b4508     mov eax,[ebp+08] [000012ed][00102180][000012e7] 50         push eax      // push P
    [000012ee][00102180][000012e7] 8b4d08     mov ecx,[ebp+08] [000012f1][0010217c][000012e7] 51         push ecx      // push P
    [000012f2][00102178][000012f7] e880feffff call 00001177 // call H

    Begin Local Halt Decider Simulation   Execution Trace Stored at:212244 [000012e7][00212230][00212234] 55          push ebp      // enter
    emulated P
    [000012e8][00212230][00212234] 8bec        mov ebp,esp [000012ea][00212230][00212234] 8b4508      mov eax,[ebp+08] [000012ed][0021222c][000012e7] 50          push eax      // push P
    [000012ee][0021222c][000012e7] 8b4d08      mov ecx,[ebp+08] [000012f1][00212228][000012e7] 51          push ecx      // push P
    [000012f2][00212224][000012f7] e880feffff  call 00001177 // call H

    So, by what instruction reference manual is a call 00001177 followedby
    the execution of the instruction at 000012e7.

    Your "CPU" is broken, or emulation incorrect.

    FAIL.

    [000012e7][0025cc58][0025cc5c] 55          push ebp      // enter
    emulated P
    [000012e8][0025cc58][0025cc5c] 8bec        mov ebp,esp [000012ea][0025cc58][0025cc5c] 8b4508      mov eax,[ebp+08] [000012ed][0025cc54][000012e7] 50          push eax      // push P
    [000012ee][0025cc54][000012e7] 8b4d08      mov ecx,[ebp+08] [000012f1][0025cc50][000012e7] 51          push ecx      // push P
    [000012f2][0025cc4c][000012f7] e880feffff  call 00001177 // call H
    Local Halt Decider: Infinite Recursion Detected Simulation Stopped

    It is completely obvious that when H(P,P) correctly emulates its input
    that it must emulate the first seven instructions of P. Because the
    seventh instruction of P repeats this process we know with complete
    certainty that the correct and complete emulation of P by H would never
    reach its final “ret” instruction, thus never halts.

    Problem, the 7th intruction DOESN't "Just repeat the procedure", because
    that H always has the option to abort its simulation, just like this
    onne did, and return to its P and see it halt.

    All you have shown is that either:
    H isn't a computation, not behaving the same for all copies given the
    same input, and thus, by definition, nat a halt decider, or

    H doesn't CORRECT analysis its simulation of its input.


    [000012f7][00102184][00102190] 83c408      add esp,+08 [000012fa][00102184][00102190] 85c0        test eax,eax [000012fc][00102184][00102190] 7402        jz 00001300 [00001300][00102188][00001314] 5d          pop ebp [00001301][0010218c][000012e7] c3          ret           // executed P
    halts
    [00001314][00102190][00000000] 83c404      add esp,+04 [00001317][00102190][00000000] 33c0        xor eax,eax [00001319][00102194][00100000] 5d          pop ebp [0000131a][00102198][00000000] c3          ret          // main() halts
    Number of Instructions Executed(15900)

    And thus at the end, your trace shows that P(P) Halted, and thus the
    CORRECT answer for H(P,P) needs to be 1.

    Your logic, as pointed out above, is UNSOUND.

    YOU FAIL.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Thu Jun 9 13:06:57 2022
    XPost: comp.theory, sci.logic, sci.math

    On 6/9/22 12:54 PM, olcott wrote:
    On 6/9/2022 11:34 AM, Richard Damon wrote:
    On 6/9/22 11:47 AM, olcott wrote:
    void P(u32 x)
    {
       if (H(x, x))
         HERE: goto HERE;
       return;
    }

    int main()
    {
       P(P);
    }

    _P()
    [000012e7](01)  55              push ebp
    [000012e8](02)  8bec            mov ebp,esp
    [000012ea](03)  8b4508          mov eax,[ebp+08]
    [000012ed](01)  50              push eax
    [000012ee](03)  8b4d08          mov ecx,[ebp+08]
    [000012f1](01)  51              push ecx
    [000012f2](05)  e880feffff      call 00001177 // call H
    [000012f7](03)  83c408          add esp,+08
    [000012fa](02)  85c0            test eax,eax
    [000012fc](02)  7402            jz 00001300
    [000012fe](02)  ebfe            jmp 000012fe
    [00001300](01)  5d              pop ebp
    [00001301](01)  c3              ret
    Size in bytes:(0027) [00001301]

    _main()
    [00001307](01)  55              push ebp
    [00001308](02)  8bec            mov ebp,esp
    [0000130a](05)  68e7120000      push 000012e7 // push P
    [0000130f](05)  e8d3ffffff      call 000012e7 // call P
    [00001314](03)  83c404          add esp,+04
    [00001317](02)  33c0            xor eax,eax
    [00001319](01)  5d              pop ebp
    [0000131a](01)  c3              ret
    Size in bytes:(0020) [0000131a]

      machine   stack     stack     machine    assembly
      address   address   data      code       language
      ========  ========  ========  =========  =============
    [00001307][00102190][00000000] 55         push ebp
    [00001308][00102190][00000000] 8bec       mov ebp,esp
    [0000130a][0010218c][000012e7] 68e7120000 push 000012e7 // push P
    [0000130f][00102188][00001314] e8d3ffffff call 000012e7 // call P
    [000012e7][00102184][00102190] 55         push ebp      // enter
    executed P
    [000012e8][00102184][00102190] 8bec       mov ebp,esp
    [000012ea][00102184][00102190] 8b4508     mov eax,[ebp+08]
    [000012ed][00102180][000012e7] 50         push eax      // push P
    [000012ee][00102180][000012e7] 8b4d08     mov ecx,[ebp+08]
    [000012f1][0010217c][000012e7] 51         push ecx      // push P
    [000012f2][00102178][000012f7] e880feffff call 00001177 // call H

    Begin Local Halt Decider Simulation   Execution Trace Stored at:212244 >>> [000012e7][00212230][00212234] 55          push ebp      // enter
    emulated P
    [000012e8][00212230][00212234] 8bec        mov ebp,esp
    [000012ea][00212230][00212234] 8b4508      mov eax,[ebp+08]
    [000012ed][0021222c][000012e7] 50          push eax      // push P
    [000012ee][0021222c][000012e7] 8b4d08      mov ecx,[ebp+08]
    [000012f1][00212228][000012e7] 51          push ecx      // push P
    [000012f2][00212224][000012f7] e880feffff  call 00001177 // call H

    So, by what instruction reference manual is a call 00001177 followedby
    the execution of the instruction at 000012e7.

    Your "CPU" is broken, or emulation incorrect.

    FAIL.

    [000012e7][0025cc58][0025cc5c] 55          push ebp      // enter
    emulated P
    [000012e8][0025cc58][0025cc5c] 8bec        mov ebp,esp
    [000012ea][0025cc58][0025cc5c] 8b4508      mov eax,[ebp+08]
    [000012ed][0025cc54][000012e7] 50          push eax      // push P
    [000012ee][0025cc54][000012e7] 8b4d08      mov ecx,[ebp+08]
    [000012f1][0025cc50][000012e7] 51          push ecx      // push P
    [000012f2][0025cc4c][000012f7] e880feffff  call 00001177 // call H
    Local Halt Decider: Infinite Recursion Detected Simulation Stopped

    It is completely obvious that when H(P,P) correctly emulates its
    input that it must emulate the first seven instructions of P. Because
    the seventh instruction of P repeats this process we know with
    complete certainty that the correct and complete emulation of P by H
    would never reach its final “ret” instruction, thus never halts.

    Problem, the 7th intruction DOESN't "Just repeat the procedure",
    because that H always has the option to abort its simulation, just
    like this onne did, and return to its P and see it halt.

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO ACTUAL REBUTTAL
    AT ALL:

    The partial correct x86 emulation of the input to H(P,P) conclusively
    proves that the complete and correct x86 emulation would never stop
    running.



    You SAY that, but you don't answer the actual questions about HOW.

    This shows you are just an idiot, parroting ideas that you don't
    actually understand.

    It really looks like you have gaslighted yourself into believing your
    own lies.

    HOW is the correct simulation of a CALL 00001177 instruction not
    followed by the instruction at 00001177 ?

    If you can't explain that, you just prove that you don't understand what
    you are saying.

    the actual FACTS show you are wrong.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mr Flibble@21:1/5 to olcott on Thu Jun 9 18:28:47 2022
    XPost: comp.theory, sci.logic, sci.math

    On Thu, 9 Jun 2022 12:15:24 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 12:06 PM, Richard Damon wrote:
    On 6/9/22 12:54 PM, olcott wrote:
    On 6/9/2022 11:34 AM, Richard Damon wrote:
    On 6/9/22 11:47 AM, olcott wrote:
    void P(u32 x)
    {
       if (H(x, x))
         HERE: goto HERE;
       return;
    }

    int main()
    {
       P(P);
    }

    _P()
    [000012e7](01)  55              push ebp
    [000012e8](02)  8bec            mov ebp,esp
    [000012ea](03)  8b4508          mov eax,[ebp+08]
    [000012ed](01)  50              push eax
    [000012ee](03)  8b4d08          mov ecx,[ebp+08]
    [000012f1](01)  51              push ecx
    [000012f2](05)  e880feffff      call 00001177 // call H
    [000012f7](03)  83c408          add esp,+08
    [000012fa](02)  85c0            test eax,eax
    [000012fc](02)  7402            jz 00001300
    [000012fe](02)  ebfe            jmp 000012fe
    [00001300](01)  5d              pop ebp
    [00001301](01)  c3              ret
    Size in bytes:(0027) [00001301]

    _main()
    [00001307](01)  55              push ebp
    [00001308](02)  8bec            mov ebp,esp
    [0000130a](05)  68e7120000      push 000012e7 // push P
    [0000130f](05)  e8d3ffffff      call 000012e7 // call P
    [00001314](03)  83c404          add esp,+04
    [00001317](02)  33c0            xor eax,eax
    [00001319](01)  5d              pop ebp
    [0000131a](01)  c3              ret
    Size in bytes:(0020) [0000131a]

      machine   stack     stack     machine    assembly
      address   address   data      code       language >>>>   ========  ========  ========  =========  =============
    [00001307][00102190][00000000] 55         push ebp
    [00001308][00102190][00000000] 8bec       mov ebp,esp
    [0000130a][0010218c][000012e7] 68e7120000 push 000012e7 // push P
    [0000130f][00102188][00001314] e8d3ffffff call 000012e7 // call P
    [000012e7][00102184][00102190] 55         push ebp      // enter
    executed P
    [000012e8][00102184][00102190] 8bec       mov ebp,esp
    [000012ea][00102184][00102190] 8b4508     mov eax,[ebp+08]
    [000012ed][00102180][000012e7] 50         push eax      // push P
    [000012ee][00102180][000012e7] 8b4d08     mov ecx,[ebp+08]
    [000012f1][0010217c][000012e7] 51         push ecx      // push P
    [000012f2][00102178][000012f7] e880feffff call 00001177 // call H

    Begin Local Halt Decider Simulation   Execution Trace Stored
    at:212244 [000012e7][00212230][00212234] 55          push ebp >>>>   // enter emulated P
    [000012e8][00212230][00212234] 8bec        mov ebp,esp
    [000012ea][00212230][00212234] 8b4508      mov eax,[ebp+08]
    [000012ed][0021222c][000012e7] 50          push eax      // push
    P [000012ee][0021222c][000012e7] 8b4d08      mov ecx,[ebp+08]
    [000012f1][00212228][000012e7] 51          push ecx      // push
    P [000012f2][00212224][000012f7] e880feffff  call 00001177 //
    call H

    So, by what instruction reference manual is a call 00001177
    followedby the execution of the instruction at 000012e7.

    Your "CPU" is broken, or emulation incorrect.

    FAIL.

    [000012e7][0025cc58][0025cc5c] 55          push ebp      //
    enter emulated P
    [000012e8][0025cc58][0025cc5c] 8bec        mov ebp,esp
    [000012ea][0025cc58][0025cc5c] 8b4508      mov eax,[ebp+08]
    [000012ed][0025cc54][000012e7] 50          push eax      // push
    P [000012ee][0025cc54][000012e7] 8b4d08      mov ecx,[ebp+08]
    [000012f1][0025cc50][000012e7] 51          push ecx      // push
    P [000012f2][0025cc4c][000012f7] e880feffff  call 00001177 //
    call H Local Halt Decider: Infinite Recursion Detected
    Simulation Stopped

    It is completely obvious that when H(P,P) correctly emulates its
    input that it must emulate the first seven instructions of P.
    Because the seventh instruction of P repeats this process we
    know with complete certainty that the correct and complete
    emulation of P by H would never reach its final “ret”
    instruction, thus never halts.

    Problem, the 7th intruction DOESN't "Just repeat the procedure",
    because that H always has the option to abort its simulation,
    just like this onne did, and return to its P and see it halt.

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO ACTUAL
    REBUTTAL AT ALL:

    The partial correct x86 emulation of the input to H(P,P)
    conclusively proves that the complete and correct x86 emulation
    would never stop running.



    You SAY that, but you don't answer the actual questions about HOW.


    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO EVIDENCE WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE THAT THE CORRECT PARTIAL EMULATION OF THE INPUT TO H(P,P) CONCLUSIVELY PROVES THAT THE CORRECT
    AND COMPLETE X86 EMULATION OF THE INPUT TO H(P,P) WOULD NEVER STOP
    RUNNING.

    It is completely obvious that when H(P,P) correctly emulates its
    input that it must emulate the first seven instructions of P. Because
    the seventh instruction of P repeats this process we know with
    complete certainty that the correct and complete emulation of P by H
    would never reach its final “ret” instruction, thus never halts.

    If P should have halted (i.e. no infinite loop) then your simulation
    detector, S (not H), gets the answer wrong. You S is NOT a halting
    decider.

    /Flibble

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Richard Damon on Thu Jun 9 12:15:24 2022
    XPost: comp.theory, sci.logic, sci.math

    On 6/9/2022 12:06 PM, Richard Damon wrote:
    On 6/9/22 12:54 PM, olcott wrote:
    On 6/9/2022 11:34 AM, Richard Damon wrote:
    On 6/9/22 11:47 AM, olcott wrote:
    void P(u32 x)
    {
       if (H(x, x))
         HERE: goto HERE;
       return;
    }

    int main()
    {
       P(P);
    }

    _P()
    [000012e7](01)  55              push ebp
    [000012e8](02)  8bec            mov ebp,esp
    [000012ea](03)  8b4508          mov eax,[ebp+08]
    [000012ed](01)  50              push eax
    [000012ee](03)  8b4d08          mov ecx,[ebp+08]
    [000012f1](01)  51              push ecx
    [000012f2](05)  e880feffff      call 00001177 // call H
    [000012f7](03)  83c408          add esp,+08
    [000012fa](02)  85c0            test eax,eax
    [000012fc](02)  7402            jz 00001300
    [000012fe](02)  ebfe            jmp 000012fe
    [00001300](01)  5d              pop ebp
    [00001301](01)  c3              ret
    Size in bytes:(0027) [00001301]

    _main()
    [00001307](01)  55              push ebp
    [00001308](02)  8bec            mov ebp,esp
    [0000130a](05)  68e7120000      push 000012e7 // push P
    [0000130f](05)  e8d3ffffff      call 000012e7 // call P
    [00001314](03)  83c404          add esp,+04
    [00001317](02)  33c0            xor eax,eax
    [00001319](01)  5d              pop ebp
    [0000131a](01)  c3              ret
    Size in bytes:(0020) [0000131a]

      machine   stack     stack     machine    assembly
      address   address   data      code       language
      ========  ========  ========  =========  =============
    [00001307][00102190][00000000] 55         push ebp
    [00001308][00102190][00000000] 8bec       mov ebp,esp
    [0000130a][0010218c][000012e7] 68e7120000 push 000012e7 // push P
    [0000130f][00102188][00001314] e8d3ffffff call 000012e7 // call P
    [000012e7][00102184][00102190] 55         push ebp      // enter
    executed P
    [000012e8][00102184][00102190] 8bec       mov ebp,esp
    [000012ea][00102184][00102190] 8b4508     mov eax,[ebp+08]
    [000012ed][00102180][000012e7] 50         push eax      // push P
    [000012ee][00102180][000012e7] 8b4d08     mov ecx,[ebp+08]
    [000012f1][0010217c][000012e7] 51         push ecx      // push P
    [000012f2][00102178][000012f7] e880feffff call 00001177 // call H

    Begin Local Halt Decider Simulation   Execution Trace Stored at:212244 >>>> [000012e7][00212230][00212234] 55          push ebp      // enter
    emulated P
    [000012e8][00212230][00212234] 8bec        mov ebp,esp
    [000012ea][00212230][00212234] 8b4508      mov eax,[ebp+08]
    [000012ed][0021222c][000012e7] 50          push eax      // push P
    [000012ee][0021222c][000012e7] 8b4d08      mov ecx,[ebp+08]
    [000012f1][00212228][000012e7] 51          push ecx      // push P
    [000012f2][00212224][000012f7] e880feffff  call 00001177 // call H

    So, by what instruction reference manual is a call 00001177
    followedby the execution of the instruction at 000012e7.

    Your "CPU" is broken, or emulation incorrect.

    FAIL.

    [000012e7][0025cc58][0025cc5c] 55          push ebp      // enter
    emulated P
    [000012e8][0025cc58][0025cc5c] 8bec        mov ebp,esp
    [000012ea][0025cc58][0025cc5c] 8b4508      mov eax,[ebp+08]
    [000012ed][0025cc54][000012e7] 50          push eax      // push P
    [000012ee][0025cc54][000012e7] 8b4d08      mov ecx,[ebp+08]
    [000012f1][0025cc50][000012e7] 51          push ecx      // push P
    [000012f2][0025cc4c][000012f7] e880feffff  call 00001177 // call H
    Local Halt Decider: Infinite Recursion Detected Simulation Stopped

    It is completely obvious that when H(P,P) correctly emulates its
    input that it must emulate the first seven instructions of P.
    Because the seventh instruction of P repeats this process we know
    with complete certainty that the correct and complete emulation of P
    by H would never reach its final “ret” instruction, thus never halts. >>>
    Problem, the 7th intruction DOESN't "Just repeat the procedure",
    because that H always has the option to abort its simulation, just
    like this onne did, and return to its P and see it halt.

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO ACTUAL
    REBUTTAL AT ALL:

    The partial correct x86 emulation of the input to H(P,P) conclusively
    proves that the complete and correct x86 emulation would never stop
    running.



    You SAY that, but you don't answer the actual questions about HOW.


    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO EVIDENCE
    WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE THAT THE CORRECT PARTIAL
    EMULATION OF THE INPUT TO H(P,P) CONCLUSIVELY PROVES THAT THE CORRECT
    AND COMPLETE X86 EMULATION OF THE INPUT TO H(P,P) WOULD NEVER STOP
    RUNNING.

    It is completely obvious that when H(P,P) correctly emulates its input
    that it must emulate the first seven instructions of P. Because the
    seventh instruction of P repeats this process we know with complete
    certainty that the correct and complete emulation of P by H would never
    reach its final “ret” instruction, thus never halts.




    --
    Copyright 2022 Pete Olcott

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

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Mr Flibble on Thu Jun 9 12:39:32 2022
    XPost: comp.theory, sci.logic, sci.math

    On 6/9/2022 12:28 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:15:24 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 12:06 PM, Richard Damon wrote:
    On 6/9/22 12:54 PM, olcott wrote:
    On 6/9/2022 11:34 AM, Richard Damon wrote:
    On 6/9/22 11:47 AM, olcott wrote:
    void P(u32 x)
    {
       if (H(x, x))
         HERE: goto HERE;
       return;
    }

    int main()
    {
       P(P);
    }

    _P()
    [000012e7](01)  55              push ebp
    [000012e8](02)  8bec            mov ebp,esp
    [000012ea](03)  8b4508          mov eax,[ebp+08]
    [000012ed](01)  50              push eax
    [000012ee](03)  8b4d08          mov ecx,[ebp+08]
    [000012f1](01)  51              push ecx
    [000012f2](05)  e880feffff      call 00001177 // call H
    [000012f7](03)  83c408          add esp,+08
    [000012fa](02)  85c0            test eax,eax
    [000012fc](02)  7402            jz 00001300
    [000012fe](02)  ebfe            jmp 000012fe
    [00001300](01)  5d              pop ebp
    [00001301](01)  c3              ret
    Size in bytes:(0027) [00001301]

    _main()
    [00001307](01)  55              push ebp
    [00001308](02)  8bec            mov ebp,esp
    [0000130a](05)  68e7120000      push 000012e7 // push P
    [0000130f](05)  e8d3ffffff      call 000012e7 // call P
    [00001314](03)  83c404          add esp,+04
    [00001317](02)  33c0            xor eax,eax
    [00001319](01)  5d              pop ebp
    [0000131a](01)  c3              ret
    Size in bytes:(0020) [0000131a]

      machine   stack     stack     machine    assembly >>>>>>   address   address   data      code       language >>>>>>   ========  ========  ========  =========  =============
    [00001307][00102190][00000000] 55         push ebp
    [00001308][00102190][00000000] 8bec       mov ebp,esp
    [0000130a][0010218c][000012e7] 68e7120000 push 000012e7 // push P
    [0000130f][00102188][00001314] e8d3ffffff call 000012e7 // call P
    [000012e7][00102184][00102190] 55         push ebp      // enter
    executed P
    [000012e8][00102184][00102190] 8bec       mov ebp,esp
    [000012ea][00102184][00102190] 8b4508     mov eax,[ebp+08]
    [000012ed][00102180][000012e7] 50         push eax      // push P
    [000012ee][00102180][000012e7] 8b4d08     mov ecx,[ebp+08]
    [000012f1][0010217c][000012e7] 51         push ecx      // push P
    [000012f2][00102178][000012f7] e880feffff call 00001177 // call H

    Begin Local Halt Decider Simulation   Execution Trace Stored
    at:212244 [000012e7][00212230][00212234] 55          push ebp >>>>>>   // enter emulated P
    [000012e8][00212230][00212234] 8bec        mov ebp,esp
    [000012ea][00212230][00212234] 8b4508      mov eax,[ebp+08]
    [000012ed][0021222c][000012e7] 50          push eax      // push
    P [000012ee][0021222c][000012e7] 8b4d08      mov ecx,[ebp+08] >>>>>> [000012f1][00212228][000012e7] 51          push ecx      // push
    P [000012f2][00212224][000012f7] e880feffff  call 00001177 //
    call H

    So, by what instruction reference manual is a call 00001177
    followedby the execution of the instruction at 000012e7.

    Your "CPU" is broken, or emulation incorrect.

    FAIL.

    [000012e7][0025cc58][0025cc5c] 55          push ebp      //
    enter emulated P
    [000012e8][0025cc58][0025cc5c] 8bec        mov ebp,esp
    [000012ea][0025cc58][0025cc5c] 8b4508      mov eax,[ebp+08]
    [000012ed][0025cc54][000012e7] 50          push eax      // push
    P [000012ee][0025cc54][000012e7] 8b4d08      mov ecx,[ebp+08] >>>>>> [000012f1][0025cc50][000012e7] 51          push ecx      // push
    P [000012f2][0025cc4c][000012f7] e880feffff  call 00001177 //
    call H Local Halt Decider: Infinite Recursion Detected
    Simulation Stopped

    It is completely obvious that when H(P,P) correctly emulates its
    input that it must emulate the first seven instructions of P.
    Because the seventh instruction of P repeats this process we
    know with complete certainty that the correct and complete
    emulation of P by H would never reach its final “ret”
    instruction, thus never halts.

    Problem, the 7th intruction DOESN't "Just repeat the procedure",
    because that H always has the option to abort its simulation,
    just like this onne did, and return to its P and see it halt.

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO ACTUAL
    REBUTTAL AT ALL:

    The partial correct x86 emulation of the input to H(P,P)
    conclusively proves that the complete and correct x86 emulation
    would never stop running.



    You SAY that, but you don't answer the actual questions about HOW.


    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO EVIDENCE
    WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE THAT THE CORRECT PARTIAL
    EMULATION OF THE INPUT TO H(P,P) CONCLUSIVELY PROVES THAT THE CORRECT
    AND COMPLETE X86 EMULATION OF THE INPUT TO H(P,P) WOULD NEVER STOP
    RUNNING.

    It is completely obvious that when H(P,P) correctly emulates its
    input that it must emulate the first seven instructions of P. Because
    the seventh instruction of P repeats this process we know with
    complete certainty that the correct and complete emulation of P by H
    would never reach its final “ret” instruction, thus never halts.

    If P should have halted (i.e. no infinite loop) then your simulation detector, S (not H), gets the answer wrong. You S is NOT a halting
    decider.

    /Flibble


    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO ACTUAL REBUTTAL
    AT ALL.

    _P()
    [00001352](01) 55 push ebp
    [00001353](02) 8bec mov ebp,esp
    [00001355](03) 8b4508 mov eax,[ebp+08]
    [00001358](01) 50 push eax // push P
    [00001359](03) 8b4d08 mov ecx,[ebp+08]
    [0000135c](01) 51 push ecx // push P
    [0000135d](05) e840feffff call 000011a2 // call H
    [00001362](03) 83c408 add esp,+08
    [00001365](02) 85c0 test eax,eax
    [00001367](02) 7402 jz 0000136b
    [00001369](02) ebfe jmp 00001369
    [0000136b](01) 5d pop ebp
    [0000136c](01) c3 ret
    Size in bytes:(0027) [0000136c]

    It is completely obvious that when H(P,P) correctly emulates its input
    that it must emulate the first seven instructions of P. Because the
    seventh instruction of P repeats this process we know with complete
    certainty that the correct and complete emulation of P by H would never
    reach its final “ret” instruction, thus never halts.


    --
    Copyright 2022 Pete Olcott

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

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mr Flibble@21:1/5 to olcott on Thu Jun 9 18:46:17 2022
    XPost: comp.theory, sci.logic, sci.math

    On Thu, 9 Jun 2022 12:39:32 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 12:28 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:15:24 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 12:06 PM, Richard Damon wrote:
    On 6/9/22 12:54 PM, olcott wrote:
    On 6/9/2022 11:34 AM, Richard Damon wrote:
    On 6/9/22 11:47 AM, olcott wrote:
    void P(u32 x)
    {
       if (H(x, x))
         HERE: goto HERE;
       return;
    }

    int main()
    {
       P(P);
    }

    _P()
    [000012e7](01)  55              push ebp
    [000012e8](02)  8bec            mov ebp,esp
    [000012ea](03)  8b4508          mov eax,[ebp+08]
    [000012ed](01)  50              push eax
    [000012ee](03)  8b4d08          mov ecx,[ebp+08]
    [000012f1](01)  51              push ecx
    [000012f2](05)  e880feffff      call 00001177 // call H
    [000012f7](03)  83c408          add esp,+08
    [000012fa](02)  85c0            test eax,eax
    [000012fc](02)  7402            jz 00001300
    [000012fe](02)  ebfe            jmp 000012fe
    [00001300](01)  5d              pop ebp
    [00001301](01)  c3              ret
    Size in bytes:(0027) [00001301]

    _main()
    [00001307](01)  55              push ebp
    [00001308](02)  8bec            mov ebp,esp
    [0000130a](05)  68e7120000      push 000012e7 // push P
    [0000130f](05)  e8d3ffffff      call 000012e7 // call P
    [00001314](03)  83c404          add esp,+04
    [00001317](02)  33c0            xor eax,eax
    [00001319](01)  5d              pop ebp
    [0000131a](01)  c3              ret
    Size in bytes:(0020) [0000131a]

      machine   stack     stack     machine    assembly >>>>>>   address   address   data      code       language >>>>>>   ========  ========  ========  =========  =============
    [00001307][00102190][00000000] 55         push ebp
    [00001308][00102190][00000000] 8bec       mov ebp,esp
    [0000130a][0010218c][000012e7] 68e7120000 push 000012e7 //
    push P [0000130f][00102188][00001314] e8d3ffffff call 000012e7
    // call P [000012e7][00102184][00102190] 55         push ebp >>>>>>    // enter executed P
    [000012e8][00102184][00102190] 8bec       mov ebp,esp
    [000012ea][00102184][00102190] 8b4508     mov eax,[ebp+08]
    [000012ed][00102180][000012e7] 50         push eax      //
    push P [000012ee][00102180][000012e7] 8b4d08     mov
    ecx,[ebp+08] [000012f1][0010217c][000012e7] 51         push >>>>>> ecx      // push P [000012f2][00102178][000012f7] e880feffff >>>>>> call 00001177 // call H

    Begin Local Halt Decider Simulation   Execution Trace Stored
    at:212244 [000012e7][00212230][00212234] 55          push ebp >>>>>>   // enter emulated P
    [000012e8][00212230][00212234] 8bec        mov ebp,esp
    [000012ea][00212230][00212234] 8b4508      mov eax,[ebp+08] >>>>>> [000012ed][0021222c][000012e7] 50          push eax      //
    push P [000012ee][0021222c][000012e7] 8b4d08      mov
    ecx,[ebp+08] [000012f1][00212228][000012e7] 51          push >>>>>> ecx      // push P [000012f2][00212224][000012f7] e880feffff >>>>>> call 00001177 // call H

    So, by what instruction reference manual is a call 00001177
    followedby the execution of the instruction at 000012e7.

    Your "CPU" is broken, or emulation incorrect.

    FAIL.

    [000012e7][0025cc58][0025cc5c] 55          push ebp      //
    enter emulated P
    [000012e8][0025cc58][0025cc5c] 8bec        mov ebp,esp
    [000012ea][0025cc58][0025cc5c] 8b4508      mov eax,[ebp+08] >>>>>> [000012ed][0025cc54][000012e7] 50          push eax      //
    push P [000012ee][0025cc54][000012e7] 8b4d08      mov
    ecx,[ebp+08] [000012f1][0025cc50][000012e7] 51          push >>>>>> ecx      // push P [000012f2][0025cc4c][000012f7] e880feffff >>>>>> call 00001177 // call H Local Halt Decider: Infinite Recursion
    Detected Simulation Stopped

    It is completely obvious that when H(P,P) correctly emulates
    its input that it must emulate the first seven instructions of
    P. Because the seventh instruction of P repeats this process we
    know with complete certainty that the correct and complete
    emulation of P by H would never reach its final “ret”
    instruction, thus never halts.

    Problem, the 7th intruction DOESN't "Just repeat the procedure",
    because that H always has the option to abort its simulation,
    just like this onne did, and return to its P and see it halt.

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO ACTUAL
    REBUTTAL AT ALL:

    The partial correct x86 emulation of the input to H(P,P)
    conclusively proves that the complete and correct x86 emulation
    would never stop running.



    You SAY that, but you don't answer the actual questions about HOW.


    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO EVIDENCE
    WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE THAT THE CORRECT
    PARTIAL EMULATION OF THE INPUT TO H(P,P) CONCLUSIVELY PROVES THAT
    THE CORRECT AND COMPLETE X86 EMULATION OF THE INPUT TO H(P,P)
    WOULD NEVER STOP RUNNING.

    It is completely obvious that when H(P,P) correctly emulates its
    input that it must emulate the first seven instructions of P.
    Because the seventh instruction of P repeats this process we know
    with complete certainty that the correct and complete emulation of
    P by H would never reach its final “ret” instruction, thus never
    halts.

    If P should have halted (i.e. no infinite loop) then your simulation detector, S (not H), gets the answer wrong. You S is NOT a halting decider.

    /Flibble


    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO ACTUAL
    REBUTTAL AT ALL.

    _P()
    [00001352](01) 55 push ebp
    [00001353](02) 8bec mov ebp,esp
    [00001355](03) 8b4508 mov eax,[ebp+08]
    [00001358](01) 50 push eax // push P
    [00001359](03) 8b4d08 mov ecx,[ebp+08]
    [0000135c](01) 51 push ecx // push P
    [0000135d](05) e840feffff call 000011a2 // call H
    [00001362](03) 83c408 add esp,+08
    [00001365](02) 85c0 test eax,eax
    [00001367](02) 7402 jz 0000136b
    [00001369](02) ebfe jmp 00001369
    [0000136b](01) 5d pop ebp
    [0000136c](01) c3 ret
    Size in bytes:(0027) [0000136c]

    It is completely obvious that when H(P,P) correctly emulates its
    input that it must emulate the first seven instructions of P. Because
    the seventh instruction of P repeats this process we know with
    complete certainty that the correct and complete emulation of P by H
    would never reach its final “ret” instruction, thus never halts.

    We are going around and around and around in circles. I will try again:

    If you replace the opcodes "EB FE" at 00001369 with the opcodes "90 90"
    then your H gets the answer wrong: P should have halted.

    /Flibble

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Mr Flibble on Thu Jun 9 12:55:04 2022
    XPost: comp.theory, sci.logic, sci.math

    On 6/9/2022 12:46 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:39:32 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 12:28 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:15:24 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 12:06 PM, Richard Damon wrote:
    On 6/9/22 12:54 PM, olcott wrote:
    On 6/9/2022 11:34 AM, Richard Damon wrote:
    On 6/9/22 11:47 AM, olcott wrote:
    void P(u32 x)
    {
       if (H(x, x))
         HERE: goto HERE;
       return;
    }

    int main()
    {
       P(P);
    }

    _P()
    [000012e7](01)  55              push ebp
    [000012e8](02)  8bec            mov ebp,esp
    [000012ea](03)  8b4508          mov eax,[ebp+08]
    [000012ed](01)  50              push eax
    [000012ee](03)  8b4d08          mov ecx,[ebp+08]
    [000012f1](01)  51              push ecx
    [000012f2](05)  e880feffff      call 00001177 // call H
    [000012f7](03)  83c408          add esp,+08
    [000012fa](02)  85c0            test eax,eax
    [000012fc](02)  7402            jz 00001300
    [000012fe](02)  ebfe            jmp 000012fe
    [00001300](01)  5d              pop ebp
    [00001301](01)  c3              ret
    Size in bytes:(0027) [00001301]

    _main()
    [00001307](01)  55              push ebp
    [00001308](02)  8bec            mov ebp,esp
    [0000130a](05)  68e7120000      push 000012e7 // push P
    [0000130f](05)  e8d3ffffff      call 000012e7 // call P
    [00001314](03)  83c404          add esp,+04
    [00001317](02)  33c0            xor eax,eax
    [00001319](01)  5d              pop ebp
    [0000131a](01)  c3              ret
    Size in bytes:(0020) [0000131a]

      machine   stack     stack     machine    assembly >>>>>>>>   address   address   data      code       language >>>>>>>>   ========  ========  ========  =========  ============= >>>>>>>> [00001307][00102190][00000000] 55         push ebp
    [00001308][00102190][00000000] 8bec       mov ebp,esp
    [0000130a][0010218c][000012e7] 68e7120000 push 000012e7 //
    push P [0000130f][00102188][00001314] e8d3ffffff call 000012e7 >>>>>>>> // call P [000012e7][00102184][00102190] 55         push ebp >>>>>>>>    // enter executed P
    [000012e8][00102184][00102190] 8bec       mov ebp,esp
    [000012ea][00102184][00102190] 8b4508     mov eax,[ebp+08] >>>>>>>> [000012ed][00102180][000012e7] 50         push eax      //
    push P [000012ee][00102180][000012e7] 8b4d08     mov
    ecx,[ebp+08] [000012f1][0010217c][000012e7] 51         push >>>>>>>> ecx      // push P [000012f2][00102178][000012f7] e880feffff >>>>>>>> call 00001177 // call H

    Begin Local Halt Decider Simulation   Execution Trace Stored >>>>>>>> at:212244 [000012e7][00212230][00212234] 55          push ebp >>>>>>>>   // enter emulated P
    [000012e8][00212230][00212234] 8bec        mov ebp,esp
    [000012ea][00212230][00212234] 8b4508      mov eax,[ebp+08] >>>>>>>> [000012ed][0021222c][000012e7] 50          push eax      //
    push P [000012ee][0021222c][000012e7] 8b4d08      mov
    ecx,[ebp+08] [000012f1][00212228][000012e7] 51          push >>>>>>>> ecx      // push P [000012f2][00212224][000012f7] e880feffff >>>>>>>> call 00001177 // call H

    So, by what instruction reference manual is a call 00001177
    followedby the execution of the instruction at 000012e7.

    Your "CPU" is broken, or emulation incorrect.

    FAIL.

    [000012e7][0025cc58][0025cc5c] 55          push ebp      //
    enter emulated P
    [000012e8][0025cc58][0025cc5c] 8bec        mov ebp,esp
    [000012ea][0025cc58][0025cc5c] 8b4508      mov eax,[ebp+08] >>>>>>>> [000012ed][0025cc54][000012e7] 50          push eax      //
    push P [000012ee][0025cc54][000012e7] 8b4d08      mov
    ecx,[ebp+08] [000012f1][0025cc50][000012e7] 51          push >>>>>>>> ecx      // push P [000012f2][0025cc4c][000012f7] e880feffff >>>>>>>> call 00001177 // call H Local Halt Decider: Infinite Recursion >>>>>>>> Detected Simulation Stopped

    It is completely obvious that when H(P,P) correctly emulates
    its input that it must emulate the first seven instructions of >>>>>>>> P. Because the seventh instruction of P repeats this process we >>>>>>>> know with complete certainty that the correct and complete
    emulation of P by H would never reach its final “ret”
    instruction, thus never halts.

    Problem, the 7th intruction DOESN't "Just repeat the procedure", >>>>>>> because that H always has the option to abort its simulation,
    just like this onne did, and return to its P and see it halt.

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO ACTUAL
    REBUTTAL AT ALL:

    The partial correct x86 emulation of the input to H(P,P)
    conclusively proves that the complete and correct x86 emulation
    would never stop running.



    You SAY that, but you don't answer the actual questions about HOW.


    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO EVIDENCE
    WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE THAT THE CORRECT
    PARTIAL EMULATION OF THE INPUT TO H(P,P) CONCLUSIVELY PROVES THAT
    THE CORRECT AND COMPLETE X86 EMULATION OF THE INPUT TO H(P,P)
    WOULD NEVER STOP RUNNING.

    It is completely obvious that when H(P,P) correctly emulates its
    input that it must emulate the first seven instructions of P.
    Because the seventh instruction of P repeats this process we know
    with complete certainty that the correct and complete emulation of
    P by H would never reach its final “ret” instruction, thus never
    halts.

    If P should have halted (i.e. no infinite loop) then your simulation
    detector, S (not H), gets the answer wrong. You S is NOT a halting
    decider.

    /Flibble


    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO ACTUAL
    REBUTTAL AT ALL.

    _P()
    [00001352](01) 55 push ebp
    [00001353](02) 8bec mov ebp,esp
    [00001355](03) 8b4508 mov eax,[ebp+08]
    [00001358](01) 50 push eax // push P
    [00001359](03) 8b4d08 mov ecx,[ebp+08]
    [0000135c](01) 51 push ecx // push P
    [0000135d](05) e840feffff call 000011a2 // call H
    [00001362](03) 83c408 add esp,+08
    [00001365](02) 85c0 test eax,eax
    [00001367](02) 7402 jz 0000136b
    [00001369](02) ebfe jmp 00001369
    [0000136b](01) 5d pop ebp
    [0000136c](01) c3 ret
    Size in bytes:(0027) [0000136c]

    It is completely obvious that when H(P,P) correctly emulates its
    input that it must emulate the first seven instructions of P. Because
    the seventh instruction of P repeats this process we know with
    complete certainty that the correct and complete emulation of P by H
    would never reach its final “ret” instruction, thus never halts.

    We are going around and around and around in circles. I will try again:

    If you replace the opcodes "EB FE" at 00001369 with the opcodes "90 90"
    then your H gets the answer wrong: P should have halted.

    /Flibble


    As I already said before this is merely your cluelessness that when
    H(P,P) is invoked the correct x86 emulation of the input to H(P,P) makes
    and code after [0000135d] unreachable.

    https://en.wikipedia.org/wiki/Unreachable_code

    _P()
    [00001352](01) 55 push ebp
    [00001353](02) 8bec mov ebp,esp
    [00001355](03) 8b4508 mov eax,[ebp+08]
    [00001358](01) 50 push eax // push P
    [00001359](03) 8b4d08 mov ecx,[ebp+08]
    [0000135c](01) 51 push ecx // push P
    [0000135d](05) e840feffff call 000011a2 // call H
    [00001362](03) 83c408 add esp,+08
    [00001365](02) 85c0 test eax,eax
    [00001367](02) 7402 jz 0000136b
    [00001369](02) ebfe jmp 00001369
    [0000136b](01) 5d pop ebp
    [0000136c](01) c3 ret
    Size in bytes:(0027) [0000136c]

    It is completely obvious that when H(P,P) correctly emulates its input
    that it must emulate the first seven instructions of P. Because the
    seventh instruction of P repeats this process we know with complete
    certainty that the correct and complete emulation of P by H would never
    reach its final “ret” instruction, thus never halts.

    People that are not dumber than a box of rocks will understand this to
    mean that the correct x86 emulation of the input to H(P,P) by H cannot
    possibly reach any instruction after [0000135d].


    --
    Copyright 2022 Pete Olcott

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

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Thu Jun 9 14:12:42 2022
    XPost: comp.theory, sci.logic, sci.math

    On 6/9/22 1:55 PM, olcott wrote:
    On 6/9/2022 12:46 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:39:32 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 12:28 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:15:24 -0500
    olcott <NoOne@NoWhere.com> wrote:
    On 6/9/2022 12:06 PM, Richard Damon wrote:
    On 6/9/22 12:54 PM, olcott wrote:
    On 6/9/2022 11:34 AM, Richard Damon wrote:
    On 6/9/22 11:47 AM, olcott wrote:
    void P(u32 x)
    {
         if (H(x, x))
           HERE: goto HERE;
         return;
    }

    int main()
    {
         P(P);
    }

    _P()
    [000012e7](01)  55              push ebp
    [000012e8](02)  8bec            mov ebp,esp
    [000012ea](03)  8b4508          mov eax,[ebp+08]
    [000012ed](01)  50              push eax
    [000012ee](03)  8b4d08          mov ecx,[ebp+08]
    [000012f1](01)  51              push ecx
    [000012f2](05)  e880feffff      call 00001177 // call H >>>>>>>>> [000012f7](03)  83c408          add esp,+08
    [000012fa](02)  85c0            test eax,eax
    [000012fc](02)  7402            jz 00001300
    [000012fe](02)  ebfe            jmp 000012fe
    [00001300](01)  5d              pop ebp
    [00001301](01)  c3              ret
    Size in bytes:(0027) [00001301]

    _main()
    [00001307](01)  55              push ebp
    [00001308](02)  8bec            mov ebp,esp
    [0000130a](05)  68e7120000      push 000012e7 // push P >>>>>>>>> [0000130f](05)  e8d3ffffff      call 000012e7 // call P >>>>>>>>> [00001314](03)  83c404          add esp,+04
    [00001317](02)  33c0            xor eax,eax
    [00001319](01)  5d              pop ebp
    [0000131a](01)  c3              ret
    Size in bytes:(0020) [0000131a]

        machine   stack     stack     machine    assembly >>>>>>>>>     address   address   data      code       language
        ========  ========  ========  =========  ============= >>>>>>>>> [00001307][00102190][00000000] 55         push ebp
    [00001308][00102190][00000000] 8bec       mov ebp,esp
    [0000130a][0010218c][000012e7] 68e7120000 push 000012e7 //
    push P [0000130f][00102188][00001314] e8d3ffffff call 000012e7 >>>>>>>>> // call P [000012e7][00102184][00102190] 55         push ebp >>>>>>>>>     // enter executed P
    [000012e8][00102184][00102190] 8bec       mov ebp,esp
    [000012ea][00102184][00102190] 8b4508     mov eax,[ebp+08] >>>>>>>>> [000012ed][00102180][000012e7] 50         push eax      //
    push P [000012ee][00102180][000012e7] 8b4d08     mov
    ecx,[ebp+08] [000012f1][0010217c][000012e7] 51         push >>>>>>>>> ecx      // push P [000012f2][00102178][000012f7] e880feffff >>>>>>>>> call 00001177 // call H

    Begin Local Halt Decider Simulation   Execution Trace Stored >>>>>>>>> at:212244 [000012e7][00212230][00212234] 55          push ebp
        // enter emulated P
    [000012e8][00212230][00212234] 8bec        mov ebp,esp >>>>>>>>> [000012ea][00212230][00212234] 8b4508      mov eax,[ebp+08] >>>>>>>>> [000012ed][0021222c][000012e7] 50          push eax      //
    push P [000012ee][0021222c][000012e7] 8b4d08      mov
    ecx,[ebp+08] [000012f1][00212228][000012e7] 51          push >>>>>>>>> ecx      // push P [000012f2][00212224][000012f7] e880feffff >>>>>>>>> call 00001177 // call H

    So, by what instruction reference manual is a call 00001177
    followedby the execution of the instruction at 000012e7.

    Your "CPU" is broken, or emulation incorrect.

    FAIL.
    [000012e7][0025cc58][0025cc5c] 55          push ebp      //
    enter emulated P
    [000012e8][0025cc58][0025cc5c] 8bec        mov ebp,esp >>>>>>>>> [000012ea][0025cc58][0025cc5c] 8b4508      mov eax,[ebp+08] >>>>>>>>> [000012ed][0025cc54][000012e7] 50          push eax      //
    push P [000012ee][0025cc54][000012e7] 8b4d08      mov
    ecx,[ebp+08] [000012f1][0025cc50][000012e7] 51          push >>>>>>>>> ecx      // push P [000012f2][0025cc4c][000012f7] e880feffff >>>>>>>>> call 00001177 // call H Local Halt Decider: Infinite Recursion >>>>>>>>> Detected Simulation Stopped

    It is completely obvious that when H(P,P) correctly emulates >>>>>>>>> its input that it must emulate the first seven instructions of >>>>>>>>> P. Because the seventh instruction of P repeats this process we >>>>>>>>> know with complete certainty that the correct and complete
    emulation of P by H would never reach its final “ret”
    instruction, thus never halts.

    Problem, the 7th intruction DOESN't "Just repeat the procedure", >>>>>>>> because that H always has the option to abort its simulation,
    just like this onne did, and return to its P and see it halt.
    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO ACTUAL
    REBUTTAL AT ALL:

    The partial correct x86 emulation of the input to H(P,P)
    conclusively proves that the complete and correct x86 emulation
    would never stop running.


    You SAY that, but you don't answer the actual questions about HOW.

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO EVIDENCE
    WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE THAT THE CORRECT
    PARTIAL EMULATION OF THE INPUT TO H(P,P) CONCLUSIVELY PROVES THAT
    THE CORRECT AND COMPLETE X86 EMULATION OF THE INPUT TO H(P,P)
    WOULD NEVER STOP RUNNING.

    It is completely obvious that when H(P,P) correctly emulates its
    input that it must emulate the first seven instructions of P.
    Because the seventh instruction of P repeats this process we know
    with complete certainty that the correct and complete emulation of
    P by H would never reach its final “ret” instruction, thus never >>>>> halts.

    If P should have halted (i.e. no infinite loop) then your simulation
    detector, S (not H), gets the answer wrong.  You S is NOT a halting
    decider.

    /Flibble

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO ACTUAL
    REBUTTAL AT ALL.

    _P()
    [00001352](01)  55              push ebp
    [00001353](02)  8bec            mov ebp,esp
    [00001355](03)  8b4508          mov eax,[ebp+08]
    [00001358](01)  50              push eax      // push P >>> [00001359](03)  8b4d08          mov ecx,[ebp+08]
    [0000135c](01)  51              push ecx      // push P >>> [0000135d](05)  e840feffff      call 000011a2 // call H
    [00001362](03)  83c408          add esp,+08
    [00001365](02)  85c0            test eax,eax
    [00001367](02)  7402            jz 0000136b
    [00001369](02)  ebfe            jmp 00001369
    [0000136b](01)  5d              pop ebp
    [0000136c](01)  c3              ret
    Size in bytes:(0027) [0000136c]

    It is completely obvious that when H(P,P) correctly emulates its
    input that it must emulate the first seven instructions of P. Because
    the seventh instruction of P repeats this process we know with
    complete certainty that the correct and complete emulation of P by H
    would never reach its final “ret” instruction, thus never halts.

    We are going around and around and around in circles. I will try again:

    If you replace the opcodes "EB FE" at 00001369 with the opcodes "90 90"
    then your H gets the answer wrong: P should have halted.

    /Flibble


    As I already said before this is merely your cluelessness that when
    H(P,P) is invoked the correct x86 emulation of the input to H(P,P) makes
    and code after [0000135d] unreachable.

    Wrong, because when that H return the value 0, it will get there.

    0000135d is only unreachable if H never returns.

    If H never returns, then if fails to be a decider, and thus can't be a
    halt decider.

    You need to get you definition of H straight, and until you do, you
    can't make your arguement.

    Either H does abort its simulation of it input of P,P, and return 0 and
    thus P(P) is halting because that code is reached, or

    H doesn't abort but just emulates as you othertimes claim, and this does
    make P(P) non-halting, but it also make H(P,P) non-answering and thus H
    is not a decider.

    Your argument fails because you try to make be both options be true at
    the same time but they are mutually exclusive of each other. You have
    created a Liar's paradox, and are claiming that it is simultaniously
    True and False and thus resolved.

    You H is just not an actually definite function.


    https://en.wikipedia.org/wiki/Unreachable_code

    _P()
    [00001352](01)  55              push ebp
    [00001353](02)  8bec            mov ebp,esp
    [00001355](03)  8b4508          mov eax,[ebp+08]
    [00001358](01)  50              push eax      // push P [00001359](03)  8b4d08          mov ecx,[ebp+08]
    [0000135c](01)  51              push ecx      // push P [0000135d](05)  e840feffff      call 000011a2 // call H [00001362](03)  83c408          add esp,+08
    [00001365](02)  85c0            test eax,eax
    [00001367](02)  7402            jz 0000136b
    [00001369](02)  ebfe            jmp 00001369
    [0000136b](01)  5d              pop ebp
    [0000136c](01)  c3              ret
    Size in bytes:(0027) [0000136c]

    It is completely obvious that when H(P,P) correctly emulates its input
    that it must emulate the first seven instructions of P. Because the
    seventh instruction of P repeats this process we know with complete
    certainty that the correct and complete emulation of P by H would never
    reach its final “ret” instruction, thus never halts.

    The 7th instruction doesn't just repeat the process, unless H is defined
    to be an unconditional execution of its input.

    Since that is NOT your definition of H, that is a false statement, so
    your logic is UNSOUND.




    People that are not dumber than a box of rocks will understand this to
    mean that the correct x86 emulation of the input to H(P,P) by H cannot possibly reach any instruction after [0000135d].


    The correct x86 emulation of the input to H(P,P) will reach the final
    ret instruction if H(P,P) returns 0, because it aborted its simulation
    of its input (and thus doesn't meet the defintion of a 'correct' emulation).

    If H DOES do a correct and complete emulation of its input, then it
    never answers for H(P,P) so fails to be the decider it is claimed to be.

    You are just caught in assuming something that isn't true, because you
    claim to sides of a contradiction are both true.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Thu Jun 9 15:38:16 2022
    XPost: comp.theory, sci.logic, sci.math

    On 6/9/22 3:26 PM, olcott wrote:
    On 6/9/2022 1:12 PM, Richard Damon wrote:
    On 6/9/22 1:55 PM, olcott wrote:
    On 6/9/2022 12:46 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:39:32 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 12:28 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:15:24 -0500
    olcott <NoOne@NoWhere.com> wrote:
    On 6/9/2022 12:06 PM, Richard Damon wrote:
    On 6/9/22 12:54 PM, olcott wrote:
    On 6/9/2022 11:34 AM, Richard Damon wrote:
    On 6/9/22 11:47 AM, olcott wrote:
    void P(u32 x)
    {
         if (H(x, x))
           HERE: goto HERE;
         return;
    }

    int main()
    {
         P(P);
    }

    _P()
    [000012e7](01)  55              push ebp
    [000012e8](02)  8bec            mov ebp,esp
    [000012ea](03)  8b4508          mov eax,[ebp+08] >>>>>>>>>>> [000012ed](01)  50              push eax
    [000012ee](03)  8b4d08          mov ecx,[ebp+08] >>>>>>>>>>> [000012f1](01)  51              push ecx
    [000012f2](05)  e880feffff      call 00001177 // call H >>>>>>>>>>> [000012f7](03)  83c408          add esp,+08
    [000012fa](02)  85c0            test eax,eax >>>>>>>>>>> [000012fc](02)  7402            jz 00001300
    [000012fe](02)  ebfe            jmp 000012fe >>>>>>>>>>> [00001300](01)  5d              pop ebp
    [00001301](01)  c3              ret
    Size in bytes:(0027) [00001301]

    _main()
    [00001307](01)  55              push ebp
    [00001308](02)  8bec            mov ebp,esp
    [0000130a](05)  68e7120000      push 000012e7 // push P >>>>>>>>>>> [0000130f](05)  e8d3ffffff      call 000012e7 // call P >>>>>>>>>>> [00001314](03)  83c404          add esp,+04
    [00001317](02)  33c0            xor eax,eax
    [00001319](01)  5d              pop ebp
    [0000131a](01)  c3              ret
    Size in bytes:(0020) [0000131a]

        machine   stack     stack     machine    assembly
        address   address   data      code       language
        ========  ========  ========  =========  ============= >>>>>>>>>>> [00001307][00102190][00000000] 55         push ebp >>>>>>>>>>> [00001308][00102190][00000000] 8bec       mov ebp,esp >>>>>>>>>>> [0000130a][0010218c][000012e7] 68e7120000 push 000012e7 // >>>>>>>>>>> push P [0000130f][00102188][00001314] e8d3ffffff call 000012e7 >>>>>>>>>>> // call P [000012e7][00102184][00102190] 55         push ebp
        // enter executed P
    [000012e8][00102184][00102190] 8bec       mov ebp,esp >>>>>>>>>>> [000012ea][00102184][00102190] 8b4508     mov eax,[ebp+08] >>>>>>>>>>> [000012ed][00102180][000012e7] 50         push eax      //
    push P [000012ee][00102180][000012e7] 8b4d08     mov >>>>>>>>>>> ecx,[ebp+08] [000012f1][0010217c][000012e7] 51         push >>>>>>>>>>> ecx      // push P [000012f2][00102178][000012f7] e880feffff >>>>>>>>>>> call 00001177 // call H

    Begin Local Halt Decider Simulation   Execution Trace Stored >>>>>>>>>>> at:212244 [000012e7][00212230][00212234] 55          push ebp
        // enter emulated P
    [000012e8][00212230][00212234] 8bec        mov ebp,esp >>>>>>>>>>> [000012ea][00212230][00212234] 8b4508      mov eax,[ebp+08] >>>>>>>>>>> [000012ed][0021222c][000012e7] 50          push eax      //
    push P [000012ee][0021222c][000012e7] 8b4d08      mov >>>>>>>>>>> ecx,[ebp+08] [000012f1][00212228][000012e7] 51          push
    ecx      // push P [000012f2][00212224][000012f7] e880feffff >>>>>>>>>>> call 00001177 // call H

    So, by what instruction reference manual is a call 00001177 >>>>>>>>>> followedby the execution of the instruction at 000012e7.

    Your "CPU" is broken, or emulation incorrect.

    FAIL.
    [000012e7][0025cc58][0025cc5c] 55          push ebp      //
    enter emulated P
    [000012e8][0025cc58][0025cc5c] 8bec        mov ebp,esp >>>>>>>>>>> [000012ea][0025cc58][0025cc5c] 8b4508      mov eax,[ebp+08] >>>>>>>>>>> [000012ed][0025cc54][000012e7] 50          push eax      //
    push P [000012ee][0025cc54][000012e7] 8b4d08      mov >>>>>>>>>>> ecx,[ebp+08] [000012f1][0025cc50][000012e7] 51          push
    ecx      // push P [000012f2][0025cc4c][000012f7] e880feffff >>>>>>>>>>> call 00001177 // call H Local Halt Decider: Infinite Recursion >>>>>>>>>>> Detected Simulation Stopped

    It is completely obvious that when H(P,P) correctly emulates >>>>>>>>>>> its input that it must emulate the first seven instructions of >>>>>>>>>>> P. Because the seventh instruction of P repeats this process we >>>>>>>>>>> know with complete certainty that the correct and complete >>>>>>>>>>> emulation of P by H would never reach its final “ret” >>>>>>>>>>> instruction, thus never halts.

    Problem, the 7th intruction DOESN't "Just repeat the procedure", >>>>>>>>>> because that H always has the option to abort its simulation, >>>>>>>>>> just like this onne did, and return to its P and see it halt. >>>>>>>>> THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO ACTUAL >>>>>>>>> REBUTTAL AT ALL:

    The partial correct x86 emulation of the input to H(P,P)
    conclusively proves that the complete and correct x86 emulation >>>>>>>>> would never stop running.


    You SAY that, but you don't answer the actual questions about HOW. >>>>>>>
    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO EVIDENCE >>>>>>> WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE THAT THE CORRECT
    PARTIAL EMULATION OF THE INPUT TO H(P,P) CONCLUSIVELY PROVES THAT >>>>>>> THE CORRECT AND COMPLETE X86 EMULATION OF THE INPUT TO H(P,P)
    WOULD NEVER STOP RUNNING.

    It is completely obvious that when H(P,P) correctly emulates its >>>>>>> input that it must emulate the first seven instructions of P.
    Because the seventh instruction of P repeats this process we know >>>>>>> with complete certainty that the correct and complete emulation of >>>>>>> P by H would never reach its final “ret” instruction, thus never >>>>>>> halts.

    If P should have halted (i.e. no infinite loop) then your simulation >>>>>> detector, S (not H), gets the answer wrong.  You S is NOT a halting >>>>>> decider.

    /Flibble

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO ACTUAL
    REBUTTAL AT ALL.

    _P()
    [00001352](01)  55              push ebp
    [00001353](02)  8bec            mov ebp,esp
    [00001355](03)  8b4508          mov eax,[ebp+08]
    [00001358](01)  50              push eax      // push P
    [00001359](03)  8b4d08          mov ecx,[ebp+08]
    [0000135c](01)  51              push ecx      // push P
    [0000135d](05)  e840feffff      call 000011a2 // call H
    [00001362](03)  83c408          add esp,+08
    [00001365](02)  85c0            test eax,eax
    [00001367](02)  7402            jz 0000136b
    [00001369](02)  ebfe            jmp 00001369
    [0000136b](01)  5d              pop ebp
    [0000136c](01)  c3              ret
    Size in bytes:(0027) [0000136c]

    It is completely obvious that when H(P,P) correctly emulates its
    input that it must emulate the first seven instructions of P. Because >>>>> the seventh instruction of P repeats this process we know with
    complete certainty that the correct and complete emulation of P by H >>>>> would never reach its final “ret” instruction, thus never halts.

    We are going around and around and around in circles. I will try again: >>>>
    If you replace the opcodes "EB FE" at 00001369 with the opcodes "90 90" >>>> then your H gets the answer wrong: P should have halted.

    /Flibble


    As I already said before this is merely your cluelessness that when
    H(P,P) is invoked the correct x86 emulation of the input to H(P,P)
    makes and code after [0000135d] unreachable.

    Wrong, because when that H return the value 0, it will get there.
    Like I said people that are dumber than a box of rocks won't be able to correctly understand this.

    When H(P,P) is invoked the correctly emulated input to H(P,P) cannot
    possibly reach any instruction beyond [0000135d].

    So, you are defining that you H(P,P) never returns because it is caught
    in the infinite rcursion.

    Thats fine, just says it can't be the correctly answering decider you
    claim it to be.


    People that are very stupid might believe that once the emulation of the input to H(P,P) has been aborted that this dead process will magically
    leap to [0000136c] even though it is a dead process.


    What "Dead Process". We aren't asking about the partial simulation that
    H is doing, we are asking about the ACTUAL machine that the input
    represents.

    H can't abort that, because nothing can. P. once designed instantly
    creates a mapping from all input to results, and if H(P,P) returns 0,
    that mapping is P(P) will Halt.

    Maybe we just need to wait for the ultimate master to abort YOUR
    emulation, leaving just a "dead process" and ending this debacle.

    It is clear you don't understand what a Turing Machine is.

    You can abort your emulation of the Turing Machine, you can't abort the
    actual Turing Machine. Thats like defining a sequence of the numbers 1
    to 10, but trying to stop in at 5.

    Once you define the sequnce, it is there. Once you derine the Machine,
    its behavior for all inputs is defined. Doesn't matter if you abort your simulation of it.

    It seems your reasoning aborted some point a couple of decades ago.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Richard Damon on Thu Jun 9 14:26:53 2022
    XPost: comp.theory, sci.logic, sci.math

    On 6/9/2022 1:12 PM, Richard Damon wrote:
    On 6/9/22 1:55 PM, olcott wrote:
    On 6/9/2022 12:46 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:39:32 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 12:28 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:15:24 -0500
    olcott <NoOne@NoWhere.com> wrote:
    On 6/9/2022 12:06 PM, Richard Damon wrote:
    On 6/9/22 12:54 PM, olcott wrote:
    On 6/9/2022 11:34 AM, Richard Damon wrote:
    On 6/9/22 11:47 AM, olcott wrote:
    void P(u32 x)
    {
         if (H(x, x))
           HERE: goto HERE;
         return;
    }

    int main()
    {
         P(P);
    }

    _P()
    [000012e7](01)  55              push ebp
    [000012e8](02)  8bec            mov ebp,esp
    [000012ea](03)  8b4508          mov eax,[ebp+08] >>>>>>>>>> [000012ed](01)  50              push eax
    [000012ee](03)  8b4d08          mov ecx,[ebp+08] >>>>>>>>>> [000012f1](01)  51              push ecx
    [000012f2](05)  e880feffff      call 00001177 // call H >>>>>>>>>> [000012f7](03)  83c408          add esp,+08
    [000012fa](02)  85c0            test eax,eax
    [000012fc](02)  7402            jz 00001300
    [000012fe](02)  ebfe            jmp 000012fe
    [00001300](01)  5d              pop ebp
    [00001301](01)  c3              ret
    Size in bytes:(0027) [00001301]

    _main()
    [00001307](01)  55              push ebp
    [00001308](02)  8bec            mov ebp,esp
    [0000130a](05)  68e7120000      push 000012e7 // push P >>>>>>>>>> [0000130f](05)  e8d3ffffff      call 000012e7 // call P >>>>>>>>>> [00001314](03)  83c404          add esp,+04
    [00001317](02)  33c0            xor eax,eax
    [00001319](01)  5d              pop ebp
    [0000131a](01)  c3              ret
    Size in bytes:(0020) [0000131a]

        machine   stack     stack     machine    assembly
        address   address   data      code       language
        ========  ========  ========  =========  ============= >>>>>>>>>> [00001307][00102190][00000000] 55         push ebp >>>>>>>>>> [00001308][00102190][00000000] 8bec       mov ebp,esp >>>>>>>>>> [0000130a][0010218c][000012e7] 68e7120000 push 000012e7 // >>>>>>>>>> push P [0000130f][00102188][00001314] e8d3ffffff call 000012e7 >>>>>>>>>> // call P [000012e7][00102184][00102190] 55         push ebp >>>>>>>>>>     // enter executed P
    [000012e8][00102184][00102190] 8bec       mov ebp,esp >>>>>>>>>> [000012ea][00102184][00102190] 8b4508     mov eax,[ebp+08] >>>>>>>>>> [000012ed][00102180][000012e7] 50         push eax      //
    push P [000012ee][00102180][000012e7] 8b4d08     mov
    ecx,[ebp+08] [000012f1][0010217c][000012e7] 51         push >>>>>>>>>> ecx      // push P [000012f2][00102178][000012f7] e880feffff >>>>>>>>>> call 00001177 // call H

    Begin Local Halt Decider Simulation   Execution Trace Stored >>>>>>>>>> at:212244 [000012e7][00212230][00212234] 55          push ebp
        // enter emulated P
    [000012e8][00212230][00212234] 8bec        mov ebp,esp >>>>>>>>>> [000012ea][00212230][00212234] 8b4508      mov eax,[ebp+08] >>>>>>>>>> [000012ed][0021222c][000012e7] 50          push eax      //
    push P [000012ee][0021222c][000012e7] 8b4d08      mov >>>>>>>>>> ecx,[ebp+08] [000012f1][00212228][000012e7] 51          push
    ecx      // push P [000012f2][00212224][000012f7] e880feffff >>>>>>>>>> call 00001177 // call H

    So, by what instruction reference manual is a call 00001177
    followedby the execution of the instruction at 000012e7.

    Your "CPU" is broken, or emulation incorrect.

    FAIL.
    [000012e7][0025cc58][0025cc5c] 55          push ebp      //
    enter emulated P
    [000012e8][0025cc58][0025cc5c] 8bec        mov ebp,esp >>>>>>>>>> [000012ea][0025cc58][0025cc5c] 8b4508      mov eax,[ebp+08] >>>>>>>>>> [000012ed][0025cc54][000012e7] 50          push eax      //
    push P [000012ee][0025cc54][000012e7] 8b4d08      mov >>>>>>>>>> ecx,[ebp+08] [000012f1][0025cc50][000012e7] 51          push
    ecx      // push P [000012f2][0025cc4c][000012f7] e880feffff >>>>>>>>>> call 00001177 // call H Local Halt Decider: Infinite Recursion >>>>>>>>>> Detected Simulation Stopped

    It is completely obvious that when H(P,P) correctly emulates >>>>>>>>>> its input that it must emulate the first seven instructions of >>>>>>>>>> P. Because the seventh instruction of P repeats this process we >>>>>>>>>> know with complete certainty that the correct and complete >>>>>>>>>> emulation of P by H would never reach its final “ret”
    instruction, thus never halts.

    Problem, the 7th intruction DOESN't "Just repeat the procedure", >>>>>>>>> because that H always has the option to abort its simulation, >>>>>>>>> just like this onne did, and return to its P and see it halt. >>>>>>>> THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO ACTUAL >>>>>>>> REBUTTAL AT ALL:

    The partial correct x86 emulation of the input to H(P,P)
    conclusively proves that the complete and correct x86 emulation >>>>>>>> would never stop running.


    You SAY that, but you don't answer the actual questions about HOW. >>>>>>
    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO EVIDENCE
    WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE THAT THE CORRECT
    PARTIAL EMULATION OF THE INPUT TO H(P,P) CONCLUSIVELY PROVES THAT
    THE CORRECT AND COMPLETE X86 EMULATION OF THE INPUT TO H(P,P)
    WOULD NEVER STOP RUNNING.

    It is completely obvious that when H(P,P) correctly emulates its
    input that it must emulate the first seven instructions of P.
    Because the seventh instruction of P repeats this process we know
    with complete certainty that the correct and complete emulation of >>>>>> P by H would never reach its final “ret” instruction, thus never >>>>>> halts.

    If P should have halted (i.e. no infinite loop) then your simulation >>>>> detector, S (not H), gets the answer wrong.  You S is NOT a halting >>>>> decider.

    /Flibble

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO ACTUAL
    REBUTTAL AT ALL.

    _P()
    [00001352](01)  55              push ebp
    [00001353](02)  8bec            mov ebp,esp
    [00001355](03)  8b4508          mov eax,[ebp+08]
    [00001358](01)  50              push eax      // push P >>>> [00001359](03)  8b4d08          mov ecx,[ebp+08]
    [0000135c](01)  51              push ecx      // push P >>>> [0000135d](05)  e840feffff      call 000011a2 // call H
    [00001362](03)  83c408          add esp,+08
    [00001365](02)  85c0            test eax,eax
    [00001367](02)  7402            jz 0000136b
    [00001369](02)  ebfe            jmp 00001369
    [0000136b](01)  5d              pop ebp
    [0000136c](01)  c3              ret
    Size in bytes:(0027) [0000136c]

    It is completely obvious that when H(P,P) correctly emulates its
    input that it must emulate the first seven instructions of P. Because
    the seventh instruction of P repeats this process we know with
    complete certainty that the correct and complete emulation of P by H
    would never reach its final “ret” instruction, thus never halts.

    We are going around and around and around in circles. I will try again:

    If you replace the opcodes "EB FE" at 00001369 with the opcodes "90 90"
    then your H gets the answer wrong: P should have halted.

    /Flibble


    As I already said before this is merely your cluelessness that when
    H(P,P) is invoked the correct x86 emulation of the input to H(P,P)
    makes and code after [0000135d] unreachable.

    Wrong, because when that H return the value 0, it will get there.
    Like I said people that are dumber than a box of rocks won't be able to correctly understand this.

    When H(P,P) is invoked the correctly emulated input to H(P,P) cannot
    possibly reach any instruction beyond [0000135d].

    People that are very stupid might believe that once the emulation of the
    input to H(P,P) has been aborted that this dead process will magically
    leap to [0000136c] even though it is a dead process.

    --
    Copyright 2022 Pete Olcott

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

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Richard Damon on Thu Jun 9 14:52:17 2022
    XPost: comp.theory, sci.logic, sci.math

    On 6/9/2022 2:38 PM, Richard Damon wrote:

    On 6/9/22 3:26 PM, olcott wrote:
    On 6/9/2022 1:12 PM, Richard Damon wrote:
    On 6/9/22 1:55 PM, olcott wrote:
    On 6/9/2022 12:46 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:39:32 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 12:28 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:15:24 -0500
    olcott <NoOne@NoWhere.com> wrote:
    On 6/9/2022 12:06 PM, Richard Damon wrote:
    On 6/9/22 12:54 PM, olcott wrote:
    On 6/9/2022 11:34 AM, Richard Damon wrote:
    On 6/9/22 11:47 AM, olcott wrote:
    void P(u32 x)
    {
         if (H(x, x))
           HERE: goto HERE;
         return;
    }

    int main()
    {
         P(P);
    }

    _P()
    [000012e7](01)  55              push ebp >>>>>>>>>>>> [000012e8](02)  8bec            mov ebp,esp >>>>>>>>>>>> [000012ea](03)  8b4508          mov eax,[ebp+08] >>>>>>>>>>>> [000012ed](01)  50              push eax >>>>>>>>>>>> [000012ee](03)  8b4d08          mov ecx,[ebp+08] >>>>>>>>>>>> [000012f1](01)  51              push ecx >>>>>>>>>>>> [000012f2](05)  e880feffff      call 00001177 // call H >>>>>>>>>>>> [000012f7](03)  83c408          add esp,+08
    [000012fa](02)  85c0            test eax,eax >>>>>>>>>>>> [000012fc](02)  7402            jz 00001300 >>>>>>>>>>>> [000012fe](02)  ebfe            jmp 000012fe >>>>>>>>>>>> [00001300](01)  5d              pop ebp
    [00001301](01)  c3              ret
    Size in bytes:(0027) [00001301]

    _main()
    [00001307](01)  55              push ebp >>>>>>>>>>>> [00001308](02)  8bec            mov ebp,esp >>>>>>>>>>>> [0000130a](05)  68e7120000      push 000012e7 // push P >>>>>>>>>>>> [0000130f](05)  e8d3ffffff      call 000012e7 // call P >>>>>>>>>>>> [00001314](03)  83c404          add esp,+04
    [00001317](02)  33c0            xor eax,eax >>>>>>>>>>>> [00001319](01)  5d              pop ebp
    [0000131a](01)  c3              ret
    Size in bytes:(0020) [0000131a]

        machine   stack     stack     machine    assembly
        address   address   data      code       language
        ========  ========  ========  =========  ============= >>>>>>>>>>>> [00001307][00102190][00000000] 55         push ebp >>>>>>>>>>>> [00001308][00102190][00000000] 8bec       mov ebp,esp >>>>>>>>>>>> [0000130a][0010218c][000012e7] 68e7120000 push 000012e7 // >>>>>>>>>>>> push P [0000130f][00102188][00001314] e8d3ffffff call 000012e7 >>>>>>>>>>>> // call P [000012e7][00102184][00102190] 55         push ebp
        // enter executed P
    [000012e8][00102184][00102190] 8bec       mov ebp,esp >>>>>>>>>>>> [000012ea][00102184][00102190] 8b4508     mov eax,[ebp+08] >>>>>>>>>>>> [000012ed][00102180][000012e7] 50         push eax      //
    push P [000012ee][00102180][000012e7] 8b4d08     mov >>>>>>>>>>>> ecx,[ebp+08] [000012f1][0010217c][000012e7] 51         push
    ecx      // push P [000012f2][00102178][000012f7] e880feffff >>>>>>>>>>>> call 00001177 // call H

    Begin Local Halt Decider Simulation   Execution Trace Stored >>>>>>>>>>>> at:212244 [000012e7][00212230][00212234] 55          push ebp
        // enter emulated P
    [000012e8][00212230][00212234] 8bec        mov ebp,esp >>>>>>>>>>>> [000012ea][00212230][00212234] 8b4508      mov eax,[ebp+08] >>>>>>>>>>>> [000012ed][0021222c][000012e7] 50          push eax      //
    push P [000012ee][0021222c][000012e7] 8b4d08      mov >>>>>>>>>>>> ecx,[ebp+08] [000012f1][00212228][000012e7] 51          push
    ecx      // push P [000012f2][00212224][000012f7] e880feffff >>>>>>>>>>>> call 00001177 // call H

    So, by what instruction reference manual is a call 00001177 >>>>>>>>>>> followedby the execution of the instruction at 000012e7. >>>>>>>>>>>
    Your "CPU" is broken, or emulation incorrect.

    FAIL.
    [000012e7][0025cc58][0025cc5c] 55          push ebp      //
    enter emulated P
    [000012e8][0025cc58][0025cc5c] 8bec        mov ebp,esp >>>>>>>>>>>> [000012ea][0025cc58][0025cc5c] 8b4508      mov eax,[ebp+08] >>>>>>>>>>>> [000012ed][0025cc54][000012e7] 50          push eax      //
    push P [000012ee][0025cc54][000012e7] 8b4d08      mov >>>>>>>>>>>> ecx,[ebp+08] [000012f1][0025cc50][000012e7] 51          push
    ecx      // push P [000012f2][0025cc4c][000012f7] e880feffff >>>>>>>>>>>> call 00001177 // call H Local Halt Decider: Infinite Recursion >>>>>>>>>>>> Detected Simulation Stopped

    It is completely obvious that when H(P,P) correctly emulates >>>>>>>>>>>> its input that it must emulate the first seven instructions of >>>>>>>>>>>> P. Because the seventh instruction of P repeats this process we >>>>>>>>>>>> know with complete certainty that the correct and complete >>>>>>>>>>>> emulation of P by H would never reach its final “ret” >>>>>>>>>>>> instruction, thus never halts.

    Problem, the 7th intruction DOESN't "Just repeat the procedure", >>>>>>>>>>> because that H always has the option to abort its simulation, >>>>>>>>>>> just like this onne did, and return to its P and see it halt. >>>>>>>>>> THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO ACTUAL >>>>>>>>>> REBUTTAL AT ALL:

    The partial correct x86 emulation of the input to H(P,P)
    conclusively proves that the complete and correct x86 emulation >>>>>>>>>> would never stop running.


    You SAY that, but you don't answer the actual questions about HOW. >>>>>>>>
    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO EVIDENCE >>>>>>>> WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE THAT THE CORRECT
    PARTIAL EMULATION OF THE INPUT TO H(P,P) CONCLUSIVELY PROVES THAT >>>>>>>> THE CORRECT AND COMPLETE X86 EMULATION OF THE INPUT TO H(P,P)
    WOULD NEVER STOP RUNNING.

    It is completely obvious that when H(P,P) correctly emulates its >>>>>>>> input that it must emulate the first seven instructions of P.
    Because the seventh instruction of P repeats this process we know >>>>>>>> with complete certainty that the correct and complete emulation of >>>>>>>> P by H would never reach its final “ret” instruction, thus never >>>>>>>> halts.

    If P should have halted (i.e. no infinite loop) then your simulation >>>>>>> detector, S (not H), gets the answer wrong.  You S is NOT a halting >>>>>>> decider.

    /Flibble

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO ACTUAL
    REBUTTAL AT ALL.

    _P()
    [00001352](01)  55              push ebp
    [00001353](02)  8bec            mov ebp,esp
    [00001355](03)  8b4508          mov eax,[ebp+08]
    [00001358](01)  50              push eax      // push P
    [00001359](03)  8b4d08          mov ecx,[ebp+08]
    [0000135c](01)  51              push ecx      // push P
    [0000135d](05)  e840feffff      call 000011a2 // call H
    [00001362](03)  83c408          add esp,+08
    [00001365](02)  85c0            test eax,eax
    [00001367](02)  7402            jz 0000136b
    [00001369](02)  ebfe            jmp 00001369
    [0000136b](01)  5d              pop ebp
    [0000136c](01)  c3              ret
    Size in bytes:(0027) [0000136c]

    It is completely obvious that when H(P,P) correctly emulates its
    input that it must emulate the first seven instructions of P. Because >>>>>> the seventh instruction of P repeats this process we know with
    complete certainty that the correct and complete emulation of P by H >>>>>> would never reach its final “ret” instruction, thus never halts. >>>>>
    We are going around and around and around in circles. I will try
    again:

    If you replace the opcodes "EB FE" at 00001369 with the opcodes "90
    90"
    then your H gets the answer wrong: P should have halted.

    /Flibble


    As I already said before this is merely your cluelessness that when
    H(P,P) is invoked the correct x86 emulation of the input to H(P,P)
    makes and code after [0000135d] unreachable.

    Wrong, because when that H return the value 0, it will get there.
    Like I said people that are dumber than a box of rocks won't be able
    to correctly understand this.

    When H(P,P) is invoked the correctly emulated input to H(P,P) cannot
    possibly reach any instruction beyond [0000135d].

    So, you are defining that you H(P,P) never returns because it is caught
    in the infinite rcursion.

    Thats fine, just says it can't be the correctly answering decider you
    claim it to be.

    I have corrected you on this too many times.


    --
    Copyright 2022 Pete Olcott

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

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Thu Jun 9 15:57:14 2022
    XPost: comp.theory, sci.logic, sci.math

    On 6/9/22 3:52 PM, olcott wrote:
    On 6/9/2022 2:38 PM, Richard Damon wrote:

    On 6/9/22 3:26 PM, olcott wrote:
    On 6/9/2022 1:12 PM, Richard Damon wrote:
    On 6/9/22 1:55 PM, olcott wrote:
    On 6/9/2022 12:46 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:39:32 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 12:28 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:15:24 -0500
    olcott <NoOne@NoWhere.com> wrote:
    On 6/9/2022 12:06 PM, Richard Damon wrote:
    On 6/9/22 12:54 PM, olcott wrote:
    On 6/9/2022 11:34 AM, Richard Damon wrote:
    On 6/9/22 11:47 AM, olcott wrote:
    void P(u32 x)
    {
         if (H(x, x))
           HERE: goto HERE;
         return;
    }

    int main()
    {
         P(P);
    }

    _P()
    [000012e7](01)  55              push ebp >>>>>>>>>>>>> [000012e8](02)  8bec            mov ebp,esp >>>>>>>>>>>>> [000012ea](03)  8b4508          mov eax,[ebp+08] >>>>>>>>>>>>> [000012ed](01)  50              push eax >>>>>>>>>>>>> [000012ee](03)  8b4d08          mov ecx,[ebp+08] >>>>>>>>>>>>> [000012f1](01)  51              push ecx >>>>>>>>>>>>> [000012f2](05)  e880feffff      call 00001177 // call H >>>>>>>>>>>>> [000012f7](03)  83c408          add esp,+08 >>>>>>>>>>>>> [000012fa](02)  85c0            test eax,eax >>>>>>>>>>>>> [000012fc](02)  7402            jz 00001300 >>>>>>>>>>>>> [000012fe](02)  ebfe            jmp 000012fe >>>>>>>>>>>>> [00001300](01)  5d              pop ebp >>>>>>>>>>>>> [00001301](01)  c3              ret
    Size in bytes:(0027) [00001301]

    _main()
    [00001307](01)  55              push ebp >>>>>>>>>>>>> [00001308](02)  8bec            mov ebp,esp >>>>>>>>>>>>> [0000130a](05)  68e7120000      push 000012e7 // push P >>>>>>>>>>>>> [0000130f](05)  e8d3ffffff      call 000012e7 // call P >>>>>>>>>>>>> [00001314](03)  83c404          add esp,+04 >>>>>>>>>>>>> [00001317](02)  33c0            xor eax,eax >>>>>>>>>>>>> [00001319](01)  5d              pop ebp >>>>>>>>>>>>> [0000131a](01)  c3              ret
    Size in bytes:(0020) [0000131a]

        machine   stack     stack     machine    assembly
        address   address   data      code       language
        ========  ========  ========  =========  ============= >>>>>>>>>>>>> [00001307][00102190][00000000] 55         push ebp >>>>>>>>>>>>> [00001308][00102190][00000000] 8bec       mov ebp,esp >>>>>>>>>>>>> [0000130a][0010218c][000012e7] 68e7120000 push 000012e7 // >>>>>>>>>>>>> push P [0000130f][00102188][00001314] e8d3ffffff call 000012e7 >>>>>>>>>>>>> // call P [000012e7][00102184][00102190] 55         push ebp
        // enter executed P
    [000012e8][00102184][00102190] 8bec       mov ebp,esp >>>>>>>>>>>>> [000012ea][00102184][00102190] 8b4508     mov eax,[ebp+08] >>>>>>>>>>>>> [000012ed][00102180][000012e7] 50         push eax      //
    push P [000012ee][00102180][000012e7] 8b4d08     mov >>>>>>>>>>>>> ecx,[ebp+08] [000012f1][0010217c][000012e7] 51         push
    ecx      // push P [000012f2][00102178][000012f7] e880feffff >>>>>>>>>>>>> call 00001177 // call H

    Begin Local Halt Decider Simulation   Execution Trace Stored >>>>>>>>>>>>> at:212244 [000012e7][00212230][00212234] 55          push ebp
        // enter emulated P
    [000012e8][00212230][00212234] 8bec        mov ebp,esp >>>>>>>>>>>>> [000012ea][00212230][00212234] 8b4508      mov eax,[ebp+08] >>>>>>>>>>>>> [000012ed][0021222c][000012e7] 50          push eax      //
    push P [000012ee][0021222c][000012e7] 8b4d08      mov >>>>>>>>>>>>> ecx,[ebp+08] [000012f1][00212228][000012e7] 51          push
    ecx      // push P [000012f2][00212224][000012f7] e880feffff >>>>>>>>>>>>> call 00001177 // call H

    So, by what instruction reference manual is a call 00001177 >>>>>>>>>>>> followedby the execution of the instruction at 000012e7. >>>>>>>>>>>>
    Your "CPU" is broken, or emulation incorrect.

    FAIL.
    [000012e7][0025cc58][0025cc5c] 55          push ebp      //
    enter emulated P
    [000012e8][0025cc58][0025cc5c] 8bec        mov ebp,esp >>>>>>>>>>>>> [000012ea][0025cc58][0025cc5c] 8b4508      mov eax,[ebp+08] >>>>>>>>>>>>> [000012ed][0025cc54][000012e7] 50          push eax      //
    push P [000012ee][0025cc54][000012e7] 8b4d08      mov >>>>>>>>>>>>> ecx,[ebp+08] [000012f1][0025cc50][000012e7] 51          push
    ecx      // push P [000012f2][0025cc4c][000012f7] e880feffff >>>>>>>>>>>>> call 00001177 // call H Local Halt Decider: Infinite Recursion >>>>>>>>>>>>> Detected Simulation Stopped

    It is completely obvious that when H(P,P) correctly emulates >>>>>>>>>>>>> its input that it must emulate the first seven instructions of >>>>>>>>>>>>> P. Because the seventh instruction of P repeats this >>>>>>>>>>>>> process we
    know with complete certainty that the correct and complete >>>>>>>>>>>>> emulation of P by H would never reach its final “ret” >>>>>>>>>>>>> instruction, thus never halts.

    Problem, the 7th intruction DOESN't "Just repeat the
    procedure",
    because that H always has the option to abort its simulation, >>>>>>>>>>>> just like this onne did, and return to its P and see it halt. >>>>>>>>>>> THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO ACTUAL >>>>>>>>>>> REBUTTAL AT ALL:

    The partial correct x86 emulation of the input to H(P,P) >>>>>>>>>>> conclusively proves that the complete and correct x86 emulation >>>>>>>>>>> would never stop running.


    You SAY that, but you don't answer the actual questions about >>>>>>>>>> HOW.

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO EVIDENCE >>>>>>>>> WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE THAT THE CORRECT >>>>>>>>> PARTIAL EMULATION OF THE INPUT TO H(P,P) CONCLUSIVELY PROVES THAT >>>>>>>>> THE CORRECT AND COMPLETE X86 EMULATION OF THE INPUT TO H(P,P) >>>>>>>>> WOULD NEVER STOP RUNNING.

    It is completely obvious that when H(P,P) correctly emulates its >>>>>>>>> input that it must emulate the first seven instructions of P. >>>>>>>>> Because the seventh instruction of P repeats this process we know >>>>>>>>> with complete certainty that the correct and complete emulation of >>>>>>>>> P by H would never reach its final “ret” instruction, thus never >>>>>>>>> halts.

    If P should have halted (i.e. no infinite loop) then your
    simulation
    detector, S (not H), gets the answer wrong.  You S is NOT a halting >>>>>>>> decider.

    /Flibble

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO ACTUAL
    REBUTTAL AT ALL.

    _P()
    [00001352](01)  55              push ebp
    [00001353](02)  8bec            mov ebp,esp
    [00001355](03)  8b4508          mov eax,[ebp+08]
    [00001358](01)  50              push eax      // push P
    [00001359](03)  8b4d08          mov ecx,[ebp+08]
    [0000135c](01)  51              push ecx      // push P
    [0000135d](05)  e840feffff      call 000011a2 // call H
    [00001362](03)  83c408          add esp,+08
    [00001365](02)  85c0            test eax,eax
    [00001367](02)  7402            jz 0000136b
    [00001369](02)  ebfe            jmp 00001369
    [0000136b](01)  5d              pop ebp
    [0000136c](01)  c3              ret
    Size in bytes:(0027) [0000136c]

    It is completely obvious that when H(P,P) correctly emulates its >>>>>>> input that it must emulate the first seven instructions of P.
    Because
    the seventh instruction of P repeats this process we know with
    complete certainty that the correct and complete emulation of P by H >>>>>>> would never reach its final “ret” instruction, thus never halts. >>>>>>
    We are going around and around and around in circles. I will try
    again:

    If you replace the opcodes "EB FE" at 00001369 with the opcodes
    "90 90"
    then your H gets the answer wrong: P should have halted.

    /Flibble


    As I already said before this is merely your cluelessness that when
    H(P,P) is invoked the correct x86 emulation of the input to H(P,P)
    makes and code after [0000135d] unreachable.

    Wrong, because when that H return the value 0, it will get there.
    Like I said people that are dumber than a box of rocks won't be able
    to correctly understand this.

    When H(P,P) is invoked the correctly emulated input to H(P,P) cannot
    possibly reach any instruction beyond [0000135d].

    So, you are defining that you H(P,P) never returns because it is
    caught in the infinite rcursion.

    Thats fine, just says it can't be the correctly answering decider you
    claim it to be.

    I have corrected you on this too many times.


    How. You need to define what H(P,P) actually does.

    If H(P,P) actually returns 0, then P(P) will Halt, even you have agreed
    to that.

    If H(P,P) does a correct simulation, and not abort, then while P(P)
    never halts, H(P,P) never returns 0, so it fails.

    You just keep claiming it does both at the same time.

    Let see you actually program a computation to do that. I will ask you
    what it the first instruction where the execution of the two cases
    differ, and why did it differ.

    All it shows is that your argument is caught in the Liar's paradox
    because you are a Liar.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Richard Damon on Thu Jun 9 15:13:27 2022
    XPost: comp.theory, sci.logic, sci.math

    On 6/9/2022 2:57 PM, Richard Damon wrote:
    On 6/9/22 3:52 PM, olcott wrote:
    On 6/9/2022 2:38 PM, Richard Damon wrote:

    On 6/9/22 3:26 PM, olcott wrote:
    On 6/9/2022 1:12 PM, Richard Damon wrote:
    On 6/9/22 1:55 PM, olcott wrote:
    On 6/9/2022 12:46 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:39:32 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 12:28 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:15:24 -0500
    olcott <NoOne@NoWhere.com> wrote:
    On 6/9/2022 12:06 PM, Richard Damon wrote:
    On 6/9/22 12:54 PM, olcott wrote:
    On 6/9/2022 11:34 AM, Richard Damon wrote:
    On 6/9/22 11:47 AM, olcott wrote:
    void P(u32 x)
    {
         if (H(x, x))
           HERE: goto HERE;
         return;
    }

    int main()
    {
         P(P);
    }

    _P()
    [000012e7](01)  55              push ebp >>>>>>>>>>>>>> [000012e8](02)  8bec            mov ebp,esp >>>>>>>>>>>>>> [000012ea](03)  8b4508          mov eax,[ebp+08] >>>>>>>>>>>>>> [000012ed](01)  50              push eax >>>>>>>>>>>>>> [000012ee](03)  8b4d08          mov ecx,[ebp+08] >>>>>>>>>>>>>> [000012f1](01)  51              push ecx >>>>>>>>>>>>>> [000012f2](05)  e880feffff      call 00001177 // call H >>>>>>>>>>>>>> [000012f7](03)  83c408          add esp,+08 >>>>>>>>>>>>>> [000012fa](02)  85c0            test eax,eax >>>>>>>>>>>>>> [000012fc](02)  7402            jz 00001300 >>>>>>>>>>>>>> [000012fe](02)  ebfe            jmp 000012fe >>>>>>>>>>>>>> [00001300](01)  5d              pop ebp >>>>>>>>>>>>>> [00001301](01)  c3              ret
    Size in bytes:(0027) [00001301]

    _main()
    [00001307](01)  55              push ebp >>>>>>>>>>>>>> [00001308](02)  8bec            mov ebp,esp >>>>>>>>>>>>>> [0000130a](05)  68e7120000      push 000012e7 // push P >>>>>>>>>>>>>> [0000130f](05)  e8d3ffffff      call 000012e7 // call P >>>>>>>>>>>>>> [00001314](03)  83c404          add esp,+04 >>>>>>>>>>>>>> [00001317](02)  33c0            xor eax,eax >>>>>>>>>>>>>> [00001319](01)  5d              pop ebp >>>>>>>>>>>>>> [0000131a](01)  c3              ret
    Size in bytes:(0020) [0000131a]

        machine   stack     stack     machine    assembly
        address   address   data      code       language
        ========  ========  ========  =========  =============
    [00001307][00102190][00000000] 55         push ebp >>>>>>>>>>>>>> [00001308][00102190][00000000] 8bec       mov ebp,esp >>>>>>>>>>>>>> [0000130a][0010218c][000012e7] 68e7120000 push 000012e7 // >>>>>>>>>>>>>> push P [0000130f][00102188][00001314] e8d3ffffff call >>>>>>>>>>>>>> 000012e7
    // call P [000012e7][00102184][00102190] 55         push ebp
        // enter executed P
    [000012e8][00102184][00102190] 8bec       mov ebp,esp >>>>>>>>>>>>>> [000012ea][00102184][00102190] 8b4508     mov eax,[ebp+08] >>>>>>>>>>>>>> [000012ed][00102180][000012e7] 50         push eax      //
    push P [000012ee][00102180][000012e7] 8b4d08     mov >>>>>>>>>>>>>> ecx,[ebp+08] [000012f1][0010217c][000012e7] 51         push
    ecx      // push P [000012f2][00102178][000012f7] e880feffff
    call 00001177 // call H

    Begin Local Halt Decider Simulation   Execution Trace Stored >>>>>>>>>>>>>> at:212244 [000012e7][00212230][00212234] 55          push ebp
        // enter emulated P
    [000012e8][00212230][00212234] 8bec        mov ebp,esp >>>>>>>>>>>>>> [000012ea][00212230][00212234] 8b4508      mov eax,[ebp+08] >>>>>>>>>>>>>> [000012ed][0021222c][000012e7] 50          push eax      //
    push P [000012ee][0021222c][000012e7] 8b4d08      mov >>>>>>>>>>>>>> ecx,[ebp+08] [000012f1][00212228][000012e7] 51          push
    ecx      // push P [000012f2][00212224][000012f7] e880feffff
    call 00001177 // call H

    So, by what instruction reference manual is a call 00001177 >>>>>>>>>>>>> followedby the execution of the instruction at 000012e7. >>>>>>>>>>>>>
    Your "CPU" is broken, or emulation incorrect.

    FAIL.
    [000012e7][0025cc58][0025cc5c] 55          push ebp      //
    enter emulated P
    [000012e8][0025cc58][0025cc5c] 8bec        mov ebp,esp >>>>>>>>>>>>>> [000012ea][0025cc58][0025cc5c] 8b4508      mov eax,[ebp+08] >>>>>>>>>>>>>> [000012ed][0025cc54][000012e7] 50          push eax      //
    push P [000012ee][0025cc54][000012e7] 8b4d08      mov >>>>>>>>>>>>>> ecx,[ebp+08] [000012f1][0025cc50][000012e7] 51          push
    ecx      // push P [000012f2][0025cc4c][000012f7] e880feffff
    call 00001177 // call H Local Halt Decider: Infinite >>>>>>>>>>>>>> Recursion
    Detected Simulation Stopped

    It is completely obvious that when H(P,P) correctly emulates >>>>>>>>>>>>>> its input that it must emulate the first seven
    instructions of
    P. Because the seventh instruction of P repeats this >>>>>>>>>>>>>> process we
    know with complete certainty that the correct and complete >>>>>>>>>>>>>> emulation of P by H would never reach its final “ret” >>>>>>>>>>>>>> instruction, thus never halts.

    Problem, the 7th intruction DOESN't "Just repeat the >>>>>>>>>>>>> procedure",
    because that H always has the option to abort its simulation, >>>>>>>>>>>>> just like this onne did, and return to its P and see it halt. >>>>>>>>>>>> THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO ACTUAL >>>>>>>>>>>> REBUTTAL AT ALL:

    The partial correct x86 emulation of the input to H(P,P) >>>>>>>>>>>> conclusively proves that the complete and correct x86 emulation >>>>>>>>>>>> would never stop running.


    You SAY that, but you don't answer the actual questions about >>>>>>>>>>> HOW.

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO EVIDENCE >>>>>>>>>> WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE THAT THE CORRECT >>>>>>>>>> PARTIAL EMULATION OF THE INPUT TO H(P,P) CONCLUSIVELY PROVES THAT >>>>>>>>>> THE CORRECT AND COMPLETE X86 EMULATION OF THE INPUT TO H(P,P) >>>>>>>>>> WOULD NEVER STOP RUNNING.

    It is completely obvious that when H(P,P) correctly emulates its >>>>>>>>>> input that it must emulate the first seven instructions of P. >>>>>>>>>> Because the seventh instruction of P repeats this process we know >>>>>>>>>> with complete certainty that the correct and complete
    emulation of
    P by H would never reach its final “ret” instruction, thus never >>>>>>>>>> halts.

    If P should have halted (i.e. no infinite loop) then your
    simulation
    detector, S (not H), gets the answer wrong.  You S is NOT a >>>>>>>>> halting
    decider.

    /Flibble

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO ACTUAL >>>>>>>> REBUTTAL AT ALL.

    _P()
    [00001352](01)  55              push ebp
    [00001353](02)  8bec            mov ebp,esp
    [00001355](03)  8b4508          mov eax,[ebp+08]
    [00001358](01)  50              push eax      // push P
    [00001359](03)  8b4d08          mov ecx,[ebp+08]
    [0000135c](01)  51              push ecx      // push P
    [0000135d](05)  e840feffff      call 000011a2 // call H
    [00001362](03)  83c408          add esp,+08
    [00001365](02)  85c0            test eax,eax
    [00001367](02)  7402            jz 0000136b
    [00001369](02)  ebfe            jmp 00001369
    [0000136b](01)  5d              pop ebp
    [0000136c](01)  c3              ret
    Size in bytes:(0027) [0000136c]

    It is completely obvious that when H(P,P) correctly emulates its >>>>>>>> input that it must emulate the first seven instructions of P.
    Because
    the seventh instruction of P repeats this process we know with >>>>>>>> complete certainty that the correct and complete emulation of P >>>>>>>> by H
    would never reach its final “ret” instruction, thus never halts. >>>>>>>
    We are going around and around and around in circles. I will try >>>>>>> again:

    If you replace the opcodes "EB FE" at 00001369 with the opcodes
    "90 90"
    then your H gets the answer wrong: P should have halted.

    /Flibble


    As I already said before this is merely your cluelessness that
    when H(P,P) is invoked the correct x86 emulation of the input to
    H(P,P) makes and code after [0000135d] unreachable.

    Wrong, because when that H return the value 0, it will get there.
    Like I said people that are dumber than a box of rocks won't be able
    to correctly understand this.

    When H(P,P) is invoked the correctly emulated input to H(P,P) cannot
    possibly reach any instruction beyond [0000135d].

    So, you are defining that you H(P,P) never returns because it is
    caught in the infinite rcursion.

    Thats fine, just says it can't be the correctly answering decider you
    claim it to be.

    I have corrected you on this too many times.


    How. You need to define what H(P,P) actually does.

    I have explained that too many times.

    To understand that H(P,P)==0 is correct we only need to know that H
    performs a correct x86 emulation of its input and then examine the
    execution trace.

    There is no sense explaining HOW H determines that H(P,P)==0 is correct
    until after there is a universal consensus that H(P,P)==0 is correct.




    --
    Copyright 2022 Pete Olcott

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

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Thu Jun 9 16:25:05 2022
    XPost: comp.theory, sci.logic, sci.math

    On 6/9/22 4:13 PM, olcott wrote:
    On 6/9/2022 2:57 PM, Richard Damon wrote:
    On 6/9/22 3:52 PM, olcott wrote:
    On 6/9/2022 2:38 PM, Richard Damon wrote:

    On 6/9/22 3:26 PM, olcott wrote:
    On 6/9/2022 1:12 PM, Richard Damon wrote:
    On 6/9/22 1:55 PM, olcott wrote:
    On 6/9/2022 12:46 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:39:32 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 12:28 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:15:24 -0500
    olcott <NoOne@NoWhere.com> wrote:
    On 6/9/2022 12:06 PM, Richard Damon wrote:
    On 6/9/22 12:54 PM, olcott wrote:
    On 6/9/2022 11:34 AM, Richard Damon wrote:
    On 6/9/22 11:47 AM, olcott wrote:
    void P(u32 x)
    {
         if (H(x, x))
           HERE: goto HERE;
         return;
    }

    int main()
    {
         P(P);
    }

    _P()
    [000012e7](01)  55              push ebp >>>>>>>>>>>>>>> [000012e8](02)  8bec            mov ebp,esp >>>>>>>>>>>>>>> [000012ea](03)  8b4508          mov eax,[ebp+08] >>>>>>>>>>>>>>> [000012ed](01)  50              push eax >>>>>>>>>>>>>>> [000012ee](03)  8b4d08          mov ecx,[ebp+08] >>>>>>>>>>>>>>> [000012f1](01)  51              push ecx >>>>>>>>>>>>>>> [000012f2](05)  e880feffff      call 00001177 // call H >>>>>>>>>>>>>>> [000012f7](03)  83c408          add esp,+08 >>>>>>>>>>>>>>> [000012fa](02)  85c0            test eax,eax >>>>>>>>>>>>>>> [000012fc](02)  7402            jz 00001300 >>>>>>>>>>>>>>> [000012fe](02)  ebfe            jmp 000012fe >>>>>>>>>>>>>>> [00001300](01)  5d              pop ebp >>>>>>>>>>>>>>> [00001301](01)  c3              ret >>>>>>>>>>>>>>> Size in bytes:(0027) [00001301]

    _main()
    [00001307](01)  55              push ebp >>>>>>>>>>>>>>> [00001308](02)  8bec            mov ebp,esp >>>>>>>>>>>>>>> [0000130a](05)  68e7120000      push 000012e7 // push P >>>>>>>>>>>>>>> [0000130f](05)  e8d3ffffff      call 000012e7 // call P >>>>>>>>>>>>>>> [00001314](03)  83c404          add esp,+04 >>>>>>>>>>>>>>> [00001317](02)  33c0            xor eax,eax >>>>>>>>>>>>>>> [00001319](01)  5d              pop ebp >>>>>>>>>>>>>>> [0000131a](01)  c3              ret >>>>>>>>>>>>>>> Size in bytes:(0020) [0000131a]

        machine   stack     stack     machine    assembly
        address   address   data      code       language
        ========  ========  ========  =========  =============
    [00001307][00102190][00000000] 55         push ebp >>>>>>>>>>>>>>> [00001308][00102190][00000000] 8bec       mov ebp,esp >>>>>>>>>>>>>>> [0000130a][0010218c][000012e7] 68e7120000 push 000012e7 // >>>>>>>>>>>>>>> push P [0000130f][00102188][00001314] e8d3ffffff call >>>>>>>>>>>>>>> 000012e7
    // call P [000012e7][00102184][00102190] 55         push ebp
        // enter executed P
    [000012e8][00102184][00102190] 8bec       mov ebp,esp >>>>>>>>>>>>>>> [000012ea][00102184][00102190] 8b4508     mov eax,[ebp+08] >>>>>>>>>>>>>>> [000012ed][00102180][000012e7] 50         push eax      //
    push P [000012ee][00102180][000012e7] 8b4d08     mov >>>>>>>>>>>>>>> ecx,[ebp+08] [000012f1][0010217c][000012e7] 51         push
    ecx      // push P [000012f2][00102178][000012f7] e880feffff
    call 00001177 // call H

    Begin Local Halt Decider Simulation   Execution Trace Stored >>>>>>>>>>>>>>> at:212244 [000012e7][00212230][00212234] 55          push
    ebp
        // enter emulated P
    [000012e8][00212230][00212234] 8bec        mov ebp,esp >>>>>>>>>>>>>>> [000012ea][00212230][00212234] 8b4508      mov eax,[ebp+08]
    [000012ed][0021222c][000012e7] 50          push eax      //
    push P [000012ee][0021222c][000012e7] 8b4d08      mov >>>>>>>>>>>>>>> ecx,[ebp+08] [000012f1][00212228][000012e7] 51          push
    ecx      // push P [000012f2][00212224][000012f7] e880feffff
    call 00001177 // call H

    So, by what instruction reference manual is a call 00001177 >>>>>>>>>>>>>> followedby the execution of the instruction at 000012e7. >>>>>>>>>>>>>>
    Your "CPU" is broken, or emulation incorrect.

    FAIL.
    [000012e7][0025cc58][0025cc5c] 55          push ebp      //
    enter emulated P
    [000012e8][0025cc58][0025cc5c] 8bec        mov ebp,esp >>>>>>>>>>>>>>> [000012ea][0025cc58][0025cc5c] 8b4508      mov eax,[ebp+08]
    [000012ed][0025cc54][000012e7] 50          push eax      //
    push P [000012ee][0025cc54][000012e7] 8b4d08      mov >>>>>>>>>>>>>>> ecx,[ebp+08] [000012f1][0025cc50][000012e7] 51          push
    ecx      // push P [000012f2][0025cc4c][000012f7] e880feffff
    call 00001177 // call H Local Halt Decider: Infinite >>>>>>>>>>>>>>> Recursion
    Detected Simulation Stopped

    It is completely obvious that when H(P,P) correctly emulates >>>>>>>>>>>>>>> its input that it must emulate the first seven
    instructions of
    P. Because the seventh instruction of P repeats this >>>>>>>>>>>>>>> process we
    know with complete certainty that the correct and complete >>>>>>>>>>>>>>> emulation of P by H would never reach its final “ret” >>>>>>>>>>>>>>> instruction, thus never halts.

    Problem, the 7th intruction DOESN't "Just repeat the >>>>>>>>>>>>>> procedure",
    because that H always has the option to abort its simulation, >>>>>>>>>>>>>> just like this onne did, and return to its P and see it halt. >>>>>>>>>>>>> THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO ACTUAL >>>>>>>>>>>>> REBUTTAL AT ALL:

    The partial correct x86 emulation of the input to H(P,P) >>>>>>>>>>>>> conclusively proves that the complete and correct x86 >>>>>>>>>>>>> emulation
    would never stop running.


    You SAY that, but you don't answer the actual questions >>>>>>>>>>>> about HOW.

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO EVIDENCE >>>>>>>>>>> WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE THAT THE CORRECT >>>>>>>>>>> PARTIAL EMULATION OF THE INPUT TO H(P,P) CONCLUSIVELY PROVES >>>>>>>>>>> THAT
    THE CORRECT AND COMPLETE X86 EMULATION OF THE INPUT TO H(P,P) >>>>>>>>>>> WOULD NEVER STOP RUNNING.

    It is completely obvious that when H(P,P) correctly emulates its >>>>>>>>>>> input that it must emulate the first seven instructions of P. >>>>>>>>>>> Because the seventh instruction of P repeats this process we >>>>>>>>>>> know
    with complete certainty that the correct and complete
    emulation of
    P by H would never reach its final “ret” instruction, thus never
    halts.

    If P should have halted (i.e. no infinite loop) then your
    simulation
    detector, S (not H), gets the answer wrong.  You S is NOT a >>>>>>>>>> halting
    decider.

    /Flibble

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO ACTUAL >>>>>>>>> REBUTTAL AT ALL.

    _P()
    [00001352](01)  55              push ebp
    [00001353](02)  8bec            mov ebp,esp
    [00001355](03)  8b4508          mov eax,[ebp+08]
    [00001358](01)  50              push eax      // push P
    [00001359](03)  8b4d08          mov ecx,[ebp+08]
    [0000135c](01)  51              push ecx      // push P
    [0000135d](05)  e840feffff      call 000011a2 // call H >>>>>>>>> [00001362](03)  83c408          add esp,+08
    [00001365](02)  85c0            test eax,eax
    [00001367](02)  7402            jz 0000136b
    [00001369](02)  ebfe            jmp 00001369
    [0000136b](01)  5d              pop ebp
    [0000136c](01)  c3              ret
    Size in bytes:(0027) [0000136c]

    It is completely obvious that when H(P,P) correctly emulates its >>>>>>>>> input that it must emulate the first seven instructions of P. >>>>>>>>> Because
    the seventh instruction of P repeats this process we know with >>>>>>>>> complete certainty that the correct and complete emulation of P >>>>>>>>> by H
    would never reach its final “ret” instruction, thus never halts. >>>>>>>>
    We are going around and around and around in circles. I will try >>>>>>>> again:

    If you replace the opcodes "EB FE" at 00001369 with the opcodes >>>>>>>> "90 90"
    then your H gets the answer wrong: P should have halted.

    /Flibble


    As I already said before this is merely your cluelessness that
    when H(P,P) is invoked the correct x86 emulation of the input to >>>>>>> H(P,P) makes and code after [0000135d] unreachable.

    Wrong, because when that H return the value 0, it will get there.
    Like I said people that are dumber than a box of rocks won't be
    able to correctly understand this.

    When H(P,P) is invoked the correctly emulated input to H(P,P)
    cannot possibly reach any instruction beyond [0000135d].

    So, you are defining that you H(P,P) never returns because it is
    caught in the infinite rcursion.

    Thats fine, just says it can't be the correctly answering decider
    you claim it to be.

    I have corrected you on this too many times.


    How. You need to define what H(P,P) actually does.

    I have explained that too many times.

    To understand that H(P,P)==0 is correct we only need to know that H
    performs a correct x86 emulation of its input and then examine the
    execution trace.

    And a CORRECT emulation of the code will Halt if H(P,P) returns 0, which
    it can only do if it does not actually do a correct emulation


    There is no sense explaining HOW H determines that H(P,P)==0 is correct
    until after there is a universal consensus that H(P,P)==0 is correct.


    It is correct ONLY if H(P,P) doesn't return 0.

    Note, by definition, a CORRECT emuluation never ends for a non-halting
    input.

    Thus, for H to say its input is non-halting, H can NOT have actually
    done a correct emulation.

    It might have been able to prove the input was non-halting from its
    partial simulation, as you show with infinite loop, but its emulation is
    not BY DEFINITION correct.

    For P, once you stipulate that H(P,P) will return 0, we can actually
    prove that the correct emulation of that input will Halt. so the return
    value of 0 can not be correct.

    To claim that H can do BOTH a correct emulation and return the value 0
    means, in effect, that you are declairing that infinity is a finite
    number. You are stuck in your own liar's paradox.

    The fact that you refuse to see this, just shows the limitations of your
    mental capability.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Richard Damon on Thu Jun 9 16:00:30 2022
    XPost: comp.theory, sci.logic, sci.math

    On 6/9/2022 3:25 PM, Richard Damon wrote:
    On 6/9/22 4:13 PM, olcott wrote:
    On 6/9/2022 2:57 PM, Richard Damon wrote:
    On 6/9/22 3:52 PM, olcott wrote:
    On 6/9/2022 2:38 PM, Richard Damon wrote:

    On 6/9/22 3:26 PM, olcott wrote:
    On 6/9/2022 1:12 PM, Richard Damon wrote:
    On 6/9/22 1:55 PM, olcott wrote:
    On 6/9/2022 12:46 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:39:32 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 12:28 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:15:24 -0500
    olcott <NoOne@NoWhere.com> wrote:
    On 6/9/2022 12:06 PM, Richard Damon wrote:
    On 6/9/22 12:54 PM, olcott wrote:
    On 6/9/2022 11:34 AM, Richard Damon wrote:
    On 6/9/22 11:47 AM, olcott wrote:
    void P(u32 x)
    {
         if (H(x, x))
           HERE: goto HERE;
         return;
    }

    int main()
    {
         P(P);
    }

    _P()
    [000012e7](01)  55              push ebp >>>>>>>>>>>>>>>> [000012e8](02)  8bec            mov ebp,esp >>>>>>>>>>>>>>>> [000012ea](03)  8b4508          mov eax,[ebp+08] >>>>>>>>>>>>>>>> [000012ed](01)  50              push eax >>>>>>>>>>>>>>>> [000012ee](03)  8b4d08          mov ecx,[ebp+08] >>>>>>>>>>>>>>>> [000012f1](01)  51              push ecx >>>>>>>>>>>>>>>> [000012f2](05)  e880feffff      call 00001177 // call H >>>>>>>>>>>>>>>> [000012f7](03)  83c408          add esp,+08 >>>>>>>>>>>>>>>> [000012fa](02)  85c0            test eax,eax >>>>>>>>>>>>>>>> [000012fc](02)  7402            jz 00001300 >>>>>>>>>>>>>>>> [000012fe](02)  ebfe            jmp 000012fe >>>>>>>>>>>>>>>> [00001300](01)  5d              pop ebp >>>>>>>>>>>>>>>> [00001301](01)  c3              ret >>>>>>>>>>>>>>>> Size in bytes:(0027) [00001301]

    _main()
    [00001307](01)  55              push ebp >>>>>>>>>>>>>>>> [00001308](02)  8bec            mov ebp,esp >>>>>>>>>>>>>>>> [0000130a](05)  68e7120000      push 000012e7 // push P >>>>>>>>>>>>>>>> [0000130f](05)  e8d3ffffff      call 000012e7 // call P >>>>>>>>>>>>>>>> [00001314](03)  83c404          add esp,+04 >>>>>>>>>>>>>>>> [00001317](02)  33c0            xor eax,eax >>>>>>>>>>>>>>>> [00001319](01)  5d              pop ebp >>>>>>>>>>>>>>>> [0000131a](01)  c3              ret >>>>>>>>>>>>>>>> Size in bytes:(0020) [0000131a]

        machine   stack     stack     machine    assembly
        address   address   data      code       language
        ========  ========  ========  =========  =============
    [00001307][00102190][00000000] 55         push ebp >>>>>>>>>>>>>>>> [00001308][00102190][00000000] 8bec       mov ebp,esp >>>>>>>>>>>>>>>> [0000130a][0010218c][000012e7] 68e7120000 push 000012e7 // >>>>>>>>>>>>>>>> push P [0000130f][00102188][00001314] e8d3ffffff call >>>>>>>>>>>>>>>> 000012e7
    // call P [000012e7][00102184][00102190] 55         push
    ebp
        // enter executed P
    [000012e8][00102184][00102190] 8bec       mov ebp,esp >>>>>>>>>>>>>>>> [000012ea][00102184][00102190] 8b4508     mov eax,[ebp+08] >>>>>>>>>>>>>>>> [000012ed][00102180][000012e7] 50         push eax      //
    push P [000012ee][00102180][000012e7] 8b4d08     mov >>>>>>>>>>>>>>>> ecx,[ebp+08] [000012f1][0010217c][000012e7] 51         push
    ecx      // push P [000012f2][00102178][000012f7] >>>>>>>>>>>>>>>> e880feffff
    call 00001177 // call H

    Begin Local Halt Decider Simulation   Execution Trace >>>>>>>>>>>>>>>> Stored
    at:212244 [000012e7][00212230][00212234] 55
    push ebp
        // enter emulated P
    [000012e8][00212230][00212234] 8bec        mov ebp,esp >>>>>>>>>>>>>>>> [000012ea][00212230][00212234] 8b4508      mov eax,[ebp+08]
    [000012ed][0021222c][000012e7] 50          push eax      //
    push P [000012ee][0021222c][000012e7] 8b4d08      mov >>>>>>>>>>>>>>>> ecx,[ebp+08] [000012f1][00212228][000012e7] 51 >>>>>>>>>>>>>>>> push
    ecx      // push P [000012f2][00212224][000012f7] >>>>>>>>>>>>>>>> e880feffff
    call 00001177 // call H

    So, by what instruction reference manual is a call 00001177 >>>>>>>>>>>>>>> followedby the execution of the instruction at 000012e7. >>>>>>>>>>>>>>>
    Your "CPU" is broken, or emulation incorrect.

    FAIL.
    [000012e7][0025cc58][0025cc5c] 55          push ebp      //
    enter emulated P
    [000012e8][0025cc58][0025cc5c] 8bec        mov ebp,esp >>>>>>>>>>>>>>>> [000012ea][0025cc58][0025cc5c] 8b4508      mov eax,[ebp+08]
    [000012ed][0025cc54][000012e7] 50          push eax      //
    push P [000012ee][0025cc54][000012e7] 8b4d08      mov >>>>>>>>>>>>>>>> ecx,[ebp+08] [000012f1][0025cc50][000012e7] 51 >>>>>>>>>>>>>>>> push
    ecx      // push P [000012f2][0025cc4c][000012f7] >>>>>>>>>>>>>>>> e880feffff
    call 00001177 // call H Local Halt Decider: Infinite >>>>>>>>>>>>>>>> Recursion
    Detected Simulation Stopped

    It is completely obvious that when H(P,P) correctly >>>>>>>>>>>>>>>> emulates
    its input that it must emulate the first seven >>>>>>>>>>>>>>>> instructions of
    P. Because the seventh instruction of P repeats this >>>>>>>>>>>>>>>> process we
    know with complete certainty that the correct and complete >>>>>>>>>>>>>>>> emulation of P by H would never reach its final “ret” >>>>>>>>>>>>>>>> instruction, thus never halts.

    Problem, the 7th intruction DOESN't "Just repeat the >>>>>>>>>>>>>>> procedure",
    because that H always has the option to abort its >>>>>>>>>>>>>>> simulation,
    just like this onne did, and return to its P and see it >>>>>>>>>>>>>>> halt.
    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO >>>>>>>>>>>>>> ACTUAL
    REBUTTAL AT ALL:

    The partial correct x86 emulation of the input to H(P,P) >>>>>>>>>>>>>> conclusively proves that the complete and correct x86 >>>>>>>>>>>>>> emulation
    would never stop running.


    You SAY that, but you don't answer the actual questions >>>>>>>>>>>>> about HOW.

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO >>>>>>>>>>>> EVIDENCE
    WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE THAT THE CORRECT >>>>>>>>>>>> PARTIAL EMULATION OF THE INPUT TO H(P,P) CONCLUSIVELY PROVES >>>>>>>>>>>> THAT
    THE CORRECT AND COMPLETE X86 EMULATION OF THE INPUT TO H(P,P) >>>>>>>>>>>> WOULD NEVER STOP RUNNING.

    It is completely obvious that when H(P,P) correctly emulates >>>>>>>>>>>> its
    input that it must emulate the first seven instructions of P. >>>>>>>>>>>> Because the seventh instruction of P repeats this process we >>>>>>>>>>>> know
    with complete certainty that the correct and complete
    emulation of
    P by H would never reach its final “ret” instruction, thus >>>>>>>>>>>> never
    halts.

    If P should have halted (i.e. no infinite loop) then your >>>>>>>>>>> simulation
    detector, S (not H), gets the answer wrong.  You S is NOT a >>>>>>>>>>> halting
    decider.

    /Flibble

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO ACTUAL >>>>>>>>>> REBUTTAL AT ALL.

    _P()
    [00001352](01)  55              push ebp
    [00001353](02)  8bec            mov ebp,esp
    [00001355](03)  8b4508          mov eax,[ebp+08] >>>>>>>>>> [00001358](01)  50              push eax      // push P
    [00001359](03)  8b4d08          mov ecx,[ebp+08] >>>>>>>>>> [0000135c](01)  51              push ecx      // push P
    [0000135d](05)  e840feffff      call 000011a2 // call H >>>>>>>>>> [00001362](03)  83c408          add esp,+08
    [00001365](02)  85c0            test eax,eax
    [00001367](02)  7402            jz 0000136b
    [00001369](02)  ebfe            jmp 00001369
    [0000136b](01)  5d              pop ebp
    [0000136c](01)  c3              ret
    Size in bytes:(0027) [0000136c]

    It is completely obvious that when H(P,P) correctly emulates its >>>>>>>>>> input that it must emulate the first seven instructions of P. >>>>>>>>>> Because
    the seventh instruction of P repeats this process we know with >>>>>>>>>> complete certainty that the correct and complete emulation of >>>>>>>>>> P by H
    would never reach its final “ret” instruction, thus never halts. >>>>>>>>>
    We are going around and around and around in circles. I will >>>>>>>>> try again:

    If you replace the opcodes "EB FE" at 00001369 with the opcodes >>>>>>>>> "90 90"
    then your H gets the answer wrong: P should have halted.

    /Flibble


    As I already said before this is merely your cluelessness that >>>>>>>> when H(P,P) is invoked the correct x86 emulation of the input to >>>>>>>> H(P,P) makes and code after [0000135d] unreachable.

    Wrong, because when that H return the value 0, it will get there. >>>>>> Like I said people that are dumber than a box of rocks won't be
    able to correctly understand this.

    When H(P,P) is invoked the correctly emulated input to H(P,P)
    cannot possibly reach any instruction beyond [0000135d].

    So, you are defining that you H(P,P) never returns because it is
    caught in the infinite rcursion.

    Thats fine, just says it can't be the correctly answering decider
    you claim it to be.

    I have corrected you on this too many times.


    How. You need to define what H(P,P) actually does.

    I have explained that too many times.

    To understand that H(P,P)==0 is correct we only need to know that H
    performs a correct x86 emulation of its input and then examine the
    execution trace.

    And a CORRECT emulation of the code will Halt if H(P,P) returns 0, which
    it can only do if it does not actually do a correct emulation


    The correctly emulated input to H(P,P) never gets past its machine
    address [0000135d].


    --
    Copyright 2022 Pete Olcott

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

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Thu Jun 9 17:13:19 2022
    XPost: comp.theory, sci.logic, sci.math

    On 6/9/22 5:00 PM, olcott wrote:
    On 6/9/2022 3:25 PM, Richard Damon wrote:
    On 6/9/22 4:13 PM, olcott wrote:
    On 6/9/2022 2:57 PM, Richard Damon wrote:
    On 6/9/22 3:52 PM, olcott wrote:
    On 6/9/2022 2:38 PM, Richard Damon wrote:

    On 6/9/22 3:26 PM, olcott wrote:
    On 6/9/2022 1:12 PM, Richard Damon wrote:
    On 6/9/22 1:55 PM, olcott wrote:
    On 6/9/2022 12:46 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:39:32 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 12:28 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:15:24 -0500
    olcott <NoOne@NoWhere.com> wrote:
    On 6/9/2022 12:06 PM, Richard Damon wrote:
    On 6/9/22 12:54 PM, olcott wrote:
    On 6/9/2022 11:34 AM, Richard Damon wrote:
    On 6/9/22 11:47 AM, olcott wrote:
    void P(u32 x)
    {
         if (H(x, x))
           HERE: goto HERE;
         return;
    }

    int main()
    {
         P(P);
    }

    _P()
    [000012e7](01)  55              push ebp >>>>>>>>>>>>>>>>> [000012e8](02)  8bec            mov ebp,esp >>>>>>>>>>>>>>>>> [000012ea](03)  8b4508          mov eax,[ebp+08] >>>>>>>>>>>>>>>>> [000012ed](01)  50              push eax >>>>>>>>>>>>>>>>> [000012ee](03)  8b4d08          mov ecx,[ebp+08] >>>>>>>>>>>>>>>>> [000012f1](01)  51              push ecx >>>>>>>>>>>>>>>>> [000012f2](05)  e880feffff      call 00001177 // call H >>>>>>>>>>>>>>>>> [000012f7](03)  83c408          add esp,+08 >>>>>>>>>>>>>>>>> [000012fa](02)  85c0            test eax,eax >>>>>>>>>>>>>>>>> [000012fc](02)  7402            jz 00001300 >>>>>>>>>>>>>>>>> [000012fe](02)  ebfe            jmp 000012fe >>>>>>>>>>>>>>>>> [00001300](01)  5d              pop ebp >>>>>>>>>>>>>>>>> [00001301](01)  c3              ret >>>>>>>>>>>>>>>>> Size in bytes:(0027) [00001301]

    _main()
    [00001307](01)  55              push ebp >>>>>>>>>>>>>>>>> [00001308](02)  8bec            mov ebp,esp >>>>>>>>>>>>>>>>> [0000130a](05)  68e7120000      push 000012e7 // push P >>>>>>>>>>>>>>>>> [0000130f](05)  e8d3ffffff      call 000012e7 // call P >>>>>>>>>>>>>>>>> [00001314](03)  83c404          add esp,+04 >>>>>>>>>>>>>>>>> [00001317](02)  33c0            xor eax,eax >>>>>>>>>>>>>>>>> [00001319](01)  5d              pop ebp >>>>>>>>>>>>>>>>> [0000131a](01)  c3              ret >>>>>>>>>>>>>>>>> Size in bytes:(0020) [0000131a]

        machine   stack     stack     machine    assembly
        address   address   data      code       language
        ========  ========  ========  =========  =============
    [00001307][00102190][00000000] 55         push ebp >>>>>>>>>>>>>>>>> [00001308][00102190][00000000] 8bec       mov ebp,esp >>>>>>>>>>>>>>>>> [0000130a][0010218c][000012e7] 68e7120000 push 000012e7 // >>>>>>>>>>>>>>>>> push P [0000130f][00102188][00001314] e8d3ffffff call >>>>>>>>>>>>>>>>> 000012e7
    // call P [000012e7][00102184][00102190] 55
    push ebp
        // enter executed P
    [000012e8][00102184][00102190] 8bec       mov ebp,esp >>>>>>>>>>>>>>>>> [000012ea][00102184][00102190] 8b4508     mov eax,[ebp+08]
    [000012ed][00102180][000012e7] 50         push eax      //
    push P [000012ee][00102180][000012e7] 8b4d08     mov >>>>>>>>>>>>>>>>> ecx,[ebp+08] [000012f1][0010217c][000012e7] 51 >>>>>>>>>>>>>>>>> push
    ecx      // push P [000012f2][00102178][000012f7] >>>>>>>>>>>>>>>>> e880feffff
    call 00001177 // call H

    Begin Local Halt Decider Simulation   Execution Trace >>>>>>>>>>>>>>>>> Stored
    at:212244 [000012e7][00212230][00212234] 55 push ebp >>>>>>>>>>>>>>>>>     // enter emulated P
    [000012e8][00212230][00212234] 8bec        mov ebp,esp >>>>>>>>>>>>>>>>> [000012ea][00212230][00212234] 8b4508      mov >>>>>>>>>>>>>>>>> eax,[ebp+08]
    [000012ed][0021222c][000012e7] 50          push >>>>>>>>>>>>>>>>> eax      //
    push P [000012ee][0021222c][000012e7] 8b4d08      mov >>>>>>>>>>>>>>>>> ecx,[ebp+08] [000012f1][00212228][000012e7] 51 push >>>>>>>>>>>>>>>>> ecx      // push P [000012f2][00212224][000012f7] >>>>>>>>>>>>>>>>> e880feffff
    call 00001177 // call H

    So, by what instruction reference manual is a call 00001177 >>>>>>>>>>>>>>>> followedby the execution of the instruction at 000012e7. >>>>>>>>>>>>>>>>
    Your "CPU" is broken, or emulation incorrect.

    FAIL.
    [000012e7][0025cc58][0025cc5c] 55          push >>>>>>>>>>>>>>>>> ebp      //
    enter emulated P
    [000012e8][0025cc58][0025cc5c] 8bec        mov ebp,esp >>>>>>>>>>>>>>>>> [000012ea][0025cc58][0025cc5c] 8b4508      mov >>>>>>>>>>>>>>>>> eax,[ebp+08]
    [000012ed][0025cc54][000012e7] 50          push >>>>>>>>>>>>>>>>> eax      //
    push P [000012ee][0025cc54][000012e7] 8b4d08      mov >>>>>>>>>>>>>>>>> ecx,[ebp+08] [000012f1][0025cc50][000012e7] 51 push >>>>>>>>>>>>>>>>> ecx      // push P [000012f2][0025cc4c][000012f7] >>>>>>>>>>>>>>>>> e880feffff
    call 00001177 // call H Local Halt Decider: Infinite >>>>>>>>>>>>>>>>> Recursion
    Detected Simulation Stopped

    It is completely obvious that when H(P,P) correctly >>>>>>>>>>>>>>>>> emulates
    its input that it must emulate the first seven >>>>>>>>>>>>>>>>> instructions of
    P. Because the seventh instruction of P repeats this >>>>>>>>>>>>>>>>> process we
    know with complete certainty that the correct and complete >>>>>>>>>>>>>>>>> emulation of P by H would never reach its final “ret” >>>>>>>>>>>>>>>>> instruction, thus never halts.

    Problem, the 7th intruction DOESN't "Just repeat the >>>>>>>>>>>>>>>> procedure",
    because that H always has the option to abort its >>>>>>>>>>>>>>>> simulation,
    just like this onne did, and return to its P and see it >>>>>>>>>>>>>>>> halt.
    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO >>>>>>>>>>>>>>> ACTUAL
    REBUTTAL AT ALL:

    The partial correct x86 emulation of the input to H(P,P) >>>>>>>>>>>>>>> conclusively proves that the complete and correct x86 >>>>>>>>>>>>>>> emulation
    would never stop running.


    You SAY that, but you don't answer the actual questions >>>>>>>>>>>>>> about HOW.

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO >>>>>>>>>>>>> EVIDENCE
    WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE THAT THE CORRECT >>>>>>>>>>>>> PARTIAL EMULATION OF THE INPUT TO H(P,P) CONCLUSIVELY >>>>>>>>>>>>> PROVES THAT
    THE CORRECT AND COMPLETE X86 EMULATION OF THE INPUT TO H(P,P) >>>>>>>>>>>>> WOULD NEVER STOP RUNNING.

    It is completely obvious that when H(P,P) correctly
    emulates its
    input that it must emulate the first seven instructions of P. >>>>>>>>>>>>> Because the seventh instruction of P repeats this process >>>>>>>>>>>>> we know
    with complete certainty that the correct and complete >>>>>>>>>>>>> emulation of
    P by H would never reach its final “ret” instruction, thus >>>>>>>>>>>>> never
    halts.

    If P should have halted (i.e. no infinite loop) then your >>>>>>>>>>>> simulation
    detector, S (not H), gets the answer wrong.  You S is NOT a >>>>>>>>>>>> halting
    decider.

    /Flibble

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO ACTUAL >>>>>>>>>>> REBUTTAL AT ALL.

    _P()
    [00001352](01)  55              push ebp
    [00001353](02)  8bec            mov ebp,esp
    [00001355](03)  8b4508          mov eax,[ebp+08] >>>>>>>>>>> [00001358](01)  50              push eax      // push P
    [00001359](03)  8b4d08          mov ecx,[ebp+08] >>>>>>>>>>> [0000135c](01)  51              push ecx      // push P
    [0000135d](05)  e840feffff      call 000011a2 // call H >>>>>>>>>>> [00001362](03)  83c408          add esp,+08
    [00001365](02)  85c0            test eax,eax >>>>>>>>>>> [00001367](02)  7402            jz 0000136b
    [00001369](02)  ebfe            jmp 00001369 >>>>>>>>>>> [0000136b](01)  5d              pop ebp
    [0000136c](01)  c3              ret
    Size in bytes:(0027) [0000136c]

    It is completely obvious that when H(P,P) correctly emulates its >>>>>>>>>>> input that it must emulate the first seven instructions of P. >>>>>>>>>>> Because
    the seventh instruction of P repeats this process we know with >>>>>>>>>>> complete certainty that the correct and complete emulation of >>>>>>>>>>> P by H
    would never reach its final “ret” instruction, thus never halts.

    We are going around and around and around in circles. I will >>>>>>>>>> try again:

    If you replace the opcodes "EB FE" at 00001369 with the
    opcodes "90 90"
    then your H gets the answer wrong: P should have halted.

    /Flibble


    As I already said before this is merely your cluelessness that >>>>>>>>> when H(P,P) is invoked the correct x86 emulation of the input >>>>>>>>> to H(P,P) makes and code after [0000135d] unreachable.

    Wrong, because when that H return the value 0, it will get there. >>>>>>> Like I said people that are dumber than a box of rocks won't be
    able to correctly understand this.

    When H(P,P) is invoked the correctly emulated input to H(P,P)
    cannot possibly reach any instruction beyond [0000135d].

    So, you are defining that you H(P,P) never returns because it is
    caught in the infinite rcursion.

    Thats fine, just says it can't be the correctly answering decider
    you claim it to be.

    I have corrected you on this too many times.


    How. You need to define what H(P,P) actually does.

    I have explained that too many times.

    To understand that H(P,P)==0 is correct we only need to know that H
    performs a correct x86 emulation of its input and then examine the
    execution trace.

    And a CORRECT emulation of the code will Halt if H(P,P) returns 0,
    which it can only do if it does not actually do a correct emulation


    The correctly emulated input to H(P,P) never gets past its machine
    address [0000135d].



    Only if H actually doesn't return 0. Yes, H can't correctly return 0 if
    it correctly emulates its input, but you can't drop that requirement.

    You can state a requirement that make this true several ways, but
    ultimately, you need something that constrains the behavior of H.

    It can be that H doesn't return 0
    It can be that H actaully does a correct simulation, and thus doesn't
    abort its simulation.

    You have a history of shading the truth, so you don't get a pass with
    sloppy wording.

    All statements must include the conditions that apply to them.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Richard Damon on Thu Jun 9 16:29:20 2022
    XPost: comp.theory, sci.logic, sci.math

    On 6/9/2022 4:13 PM, Richard Damon wrote:

    On 6/9/22 5:00 PM, olcott wrote:
    On 6/9/2022 3:25 PM, Richard Damon wrote:
    On 6/9/22 4:13 PM, olcott wrote:
    On 6/9/2022 2:57 PM, Richard Damon wrote:
    On 6/9/22 3:52 PM, olcott wrote:
    On 6/9/2022 2:38 PM, Richard Damon wrote:

    On 6/9/22 3:26 PM, olcott wrote:
    On 6/9/2022 1:12 PM, Richard Damon wrote:
    On 6/9/22 1:55 PM, olcott wrote:
    On 6/9/2022 12:46 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:39:32 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 12:28 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:15:24 -0500
    olcott <NoOne@NoWhere.com> wrote:
    On 6/9/2022 12:06 PM, Richard Damon wrote:
    On 6/9/22 12:54 PM, olcott wrote:
    On 6/9/2022 11:34 AM, Richard Damon wrote:
    On 6/9/22 11:47 AM, olcott wrote:
    void P(u32 x)
    {
         if (H(x, x))
           HERE: goto HERE;
         return;
    }

    int main()
    {
         P(P);
    }

    _P()
    [000012e7](01)  55              push ebp >>>>>>>>>>>>>>>>>> [000012e8](02)  8bec            mov ebp,esp >>>>>>>>>>>>>>>>>> [000012ea](03)  8b4508          mov eax,[ebp+08] >>>>>>>>>>>>>>>>>> [000012ed](01)  50              push eax >>>>>>>>>>>>>>>>>> [000012ee](03)  8b4d08          mov ecx,[ebp+08] >>>>>>>>>>>>>>>>>> [000012f1](01)  51              push ecx >>>>>>>>>>>>>>>>>> [000012f2](05)  e880feffff      call 00001177 // call H
    [000012f7](03)  83c408          add esp,+08 >>>>>>>>>>>>>>>>>> [000012fa](02)  85c0            test eax,eax >>>>>>>>>>>>>>>>>> [000012fc](02)  7402            jz 00001300 >>>>>>>>>>>>>>>>>> [000012fe](02)  ebfe            jmp 000012fe >>>>>>>>>>>>>>>>>> [00001300](01)  5d              pop ebp >>>>>>>>>>>>>>>>>> [00001301](01)  c3              ret >>>>>>>>>>>>>>>>>> Size in bytes:(0027) [00001301]

    _main()
    [00001307](01)  55              push ebp >>>>>>>>>>>>>>>>>> [00001308](02)  8bec            mov ebp,esp >>>>>>>>>>>>>>>>>> [0000130a](05)  68e7120000      push 000012e7 // push P
    [0000130f](05)  e8d3ffffff      call 000012e7 // call P
    [00001314](03)  83c404          add esp,+04 >>>>>>>>>>>>>>>>>> [00001317](02)  33c0            xor eax,eax >>>>>>>>>>>>>>>>>> [00001319](01)  5d              pop ebp >>>>>>>>>>>>>>>>>> [0000131a](01)  c3              ret >>>>>>>>>>>>>>>>>> Size in bytes:(0020) [0000131a]

        machine   stack     stack     machine    assembly
        address   address   data      code       language
        ========  ========  ========  ========= >>>>>>>>>>>>>>>>>> =============
    [00001307][00102190][00000000] 55         push ebp >>>>>>>>>>>>>>>>>> [00001308][00102190][00000000] 8bec       mov ebp,esp >>>>>>>>>>>>>>>>>> [0000130a][0010218c][000012e7] 68e7120000 push >>>>>>>>>>>>>>>>>> 000012e7 //
    push P [0000130f][00102188][00001314] e8d3ffffff call >>>>>>>>>>>>>>>>>> 000012e7
    // call P [000012e7][00102184][00102190] 55 push ebp >>>>>>>>>>>>>>>>>>     // enter executed P
    [000012e8][00102184][00102190] 8bec       mov ebp,esp >>>>>>>>>>>>>>>>>> [000012ea][00102184][00102190] 8b4508     mov >>>>>>>>>>>>>>>>>> eax,[ebp+08]
    [000012ed][00102180][000012e7] 50         push >>>>>>>>>>>>>>>>>> eax      //
    push P [000012ee][00102180][000012e7] 8b4d08     mov >>>>>>>>>>>>>>>>>> ecx,[ebp+08] [000012f1][0010217c][000012e7] 51 push >>>>>>>>>>>>>>>>>> ecx      // push P [000012f2][00102178][000012f7] >>>>>>>>>>>>>>>>>> e880feffff
    call 00001177 // call H

    Begin Local Halt Decider Simulation   Execution Trace >>>>>>>>>>>>>>>>>> Stored
    at:212244 [000012e7][00212230][00212234] 55 push ebp >>>>>>>>>>>>>>>>>>     // enter emulated P
    [000012e8][00212230][00212234] 8bec        mov ebp,esp
    [000012ea][00212230][00212234] 8b4508      mov >>>>>>>>>>>>>>>>>> eax,[ebp+08]
    [000012ed][0021222c][000012e7] 50          push >>>>>>>>>>>>>>>>>> eax      //
    push P [000012ee][0021222c][000012e7] 8b4d08      mov >>>>>>>>>>>>>>>>>> ecx,[ebp+08] [000012f1][00212228][000012e7] 51 push >>>>>>>>>>>>>>>>>> ecx      // push P [000012f2][00212224][000012f7] >>>>>>>>>>>>>>>>>> e880feffff
    call 00001177 // call H

    So, by what instruction reference manual is a call >>>>>>>>>>>>>>>>> 00001177
    followedby the execution of the instruction at 000012e7. >>>>>>>>>>>>>>>>>
    Your "CPU" is broken, or emulation incorrect. >>>>>>>>>>>>>>>>>
    FAIL.
    [000012e7][0025cc58][0025cc5c] 55          push >>>>>>>>>>>>>>>>>> ebp      //
    enter emulated P
    [000012e8][0025cc58][0025cc5c] 8bec        mov ebp,esp
    [000012ea][0025cc58][0025cc5c] 8b4508      mov >>>>>>>>>>>>>>>>>> eax,[ebp+08]
    [000012ed][0025cc54][000012e7] 50          push >>>>>>>>>>>>>>>>>> eax      //
    push P [000012ee][0025cc54][000012e7] 8b4d08      mov >>>>>>>>>>>>>>>>>> ecx,[ebp+08] [000012f1][0025cc50][000012e7] 51 push >>>>>>>>>>>>>>>>>> ecx      // push P [000012f2][0025cc4c][000012f7] >>>>>>>>>>>>>>>>>> e880feffff
    call 00001177 // call H Local Halt Decider: Infinite >>>>>>>>>>>>>>>>>> Recursion
    Detected Simulation Stopped

    It is completely obvious that when H(P,P) correctly >>>>>>>>>>>>>>>>>> emulates
    its input that it must emulate the first seven >>>>>>>>>>>>>>>>>> instructions of
    P. Because the seventh instruction of P repeats this >>>>>>>>>>>>>>>>>> process we
    know with complete certainty that the correct and >>>>>>>>>>>>>>>>>> complete
    emulation of P by H would never reach its final “ret” >>>>>>>>>>>>>>>>>> instruction, thus never halts.

    Problem, the 7th intruction DOESN't "Just repeat the >>>>>>>>>>>>>>>>> procedure",
    because that H always has the option to abort its >>>>>>>>>>>>>>>>> simulation,
    just like this onne did, and return to its P and see it >>>>>>>>>>>>>>>>> halt.
    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO >>>>>>>>>>>>>>>> ACTUAL
    REBUTTAL AT ALL:

    The partial correct x86 emulation of the input to H(P,P) >>>>>>>>>>>>>>>> conclusively proves that the complete and correct x86 >>>>>>>>>>>>>>>> emulation
    would never stop running.


    You SAY that, but you don't answer the actual questions >>>>>>>>>>>>>>> about HOW.

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO >>>>>>>>>>>>>> EVIDENCE
    WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE THAT THE CORRECT >>>>>>>>>>>>>> PARTIAL EMULATION OF THE INPUT TO H(P,P) CONCLUSIVELY >>>>>>>>>>>>>> PROVES THAT
    THE CORRECT AND COMPLETE X86 EMULATION OF THE INPUT TO H(P,P) >>>>>>>>>>>>>> WOULD NEVER STOP RUNNING.

    It is completely obvious that when H(P,P) correctly >>>>>>>>>>>>>> emulates its
    input that it must emulate the first seven instructions of P. >>>>>>>>>>>>>> Because the seventh instruction of P repeats this process >>>>>>>>>>>>>> we know
    with complete certainty that the correct and complete >>>>>>>>>>>>>> emulation of
    P by H would never reach its final “ret” instruction, thus >>>>>>>>>>>>>> never
    halts.

    If P should have halted (i.e. no infinite loop) then your >>>>>>>>>>>>> simulation
    detector, S (not H), gets the answer wrong.  You S is NOT a >>>>>>>>>>>>> halting
    decider.

    /Flibble

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO ACTUAL >>>>>>>>>>>> REBUTTAL AT ALL.

    _P()
    [00001352](01)  55              push ebp >>>>>>>>>>>> [00001353](02)  8bec            mov ebp,esp >>>>>>>>>>>> [00001355](03)  8b4508          mov eax,[ebp+08] >>>>>>>>>>>> [00001358](01)  50              push eax      // push P
    [00001359](03)  8b4d08          mov ecx,[ebp+08] >>>>>>>>>>>> [0000135c](01)  51              push ecx      // push P
    [0000135d](05)  e840feffff      call 000011a2 // call H >>>>>>>>>>>> [00001362](03)  83c408          add esp,+08
    [00001365](02)  85c0            test eax,eax >>>>>>>>>>>> [00001367](02)  7402            jz 0000136b >>>>>>>>>>>> [00001369](02)  ebfe            jmp 00001369 >>>>>>>>>>>> [0000136b](01)  5d              pop ebp
    [0000136c](01)  c3              ret
    Size in bytes:(0027) [0000136c]

    It is completely obvious that when H(P,P) correctly emulates >>>>>>>>>>>> its
    input that it must emulate the first seven instructions of >>>>>>>>>>>> P. Because
    the seventh instruction of P repeats this process we know with >>>>>>>>>>>> complete certainty that the correct and complete emulation >>>>>>>>>>>> of P by H
    would never reach its final “ret” instruction, thus never >>>>>>>>>>>> halts.

    We are going around and around and around in circles. I will >>>>>>>>>>> try again:

    If you replace the opcodes "EB FE" at 00001369 with the
    opcodes "90 90"
    then your H gets the answer wrong: P should have halted. >>>>>>>>>>>
    /Flibble


    As I already said before this is merely your cluelessness that >>>>>>>>>> when H(P,P) is invoked the correct x86 emulation of the input >>>>>>>>>> to H(P,P) makes and code after [0000135d] unreachable.

    Wrong, because when that H return the value 0, it will get there. >>>>>>>> Like I said people that are dumber than a box of rocks won't be >>>>>>>> able to correctly understand this.

    When H(P,P) is invoked the correctly emulated input to H(P,P)
    cannot possibly reach any instruction beyond [0000135d].

    So, you are defining that you H(P,P) never returns because it is >>>>>>> caught in the infinite rcursion.

    Thats fine, just says it can't be the correctly answering decider >>>>>>> you claim it to be.

    I have corrected you on this too many times.


    How. You need to define what H(P,P) actually does.

    I have explained that too many times.

    To understand that H(P,P)==0 is correct we only need to know that H
    performs a correct x86 emulation of its input and then examine the
    execution trace.

    And a CORRECT emulation of the code will Halt if H(P,P) returns 0,
    which it can only do if it does not actually do a correct emulation


    The correctly emulated input to H(P,P) never gets past its machine
    address [0000135d].



    Only if H actually doesn't return 0. Yes, H can't correctly return 0 if
    it correctly emulates its input, but you can't drop that requirement.

    void P(u32 x)
    {
    if (H(x, x))
    HERE: goto HERE;
    return;
    }

    int main()
    {
    Output("Input_Halts = ", H((u32)P, (u32)P));
    }

    When H returns 0 it does not returns 0 to P it returns 0 to main().
    --
    Copyright 2022 Pete Olcott

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

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Thu Jun 9 17:54:11 2022
    XPost: comp.theory, sci.logic, sci.math

    On 6/9/22 5:29 PM, olcott wrote:
    On 6/9/2022 4:13 PM, Richard Damon wrote:

    On 6/9/22 5:00 PM, olcott wrote:
    On 6/9/2022 3:25 PM, Richard Damon wrote:
    On 6/9/22 4:13 PM, olcott wrote:
    On 6/9/2022 2:57 PM, Richard Damon wrote:
    On 6/9/22 3:52 PM, olcott wrote:
    On 6/9/2022 2:38 PM, Richard Damon wrote:

    On 6/9/22 3:26 PM, olcott wrote:
    On 6/9/2022 1:12 PM, Richard Damon wrote:
    On 6/9/22 1:55 PM, olcott wrote:
    On 6/9/2022 12:46 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:39:32 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 12:28 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:15:24 -0500
    olcott <NoOne@NoWhere.com> wrote:
    On 6/9/2022 12:06 PM, Richard Damon wrote:
    On 6/9/22 12:54 PM, olcott wrote:
    On 6/9/2022 11:34 AM, Richard Damon wrote:
    On 6/9/22 11:47 AM, olcott wrote:
    void P(u32 x)
    {
         if (H(x, x))
           HERE: goto HERE;
         return;
    }

    int main()
    {
         P(P);
    }

    _P()
    [000012e7](01)  55              push ebp >>>>>>>>>>>>>>>>>>> [000012e8](02)  8bec            mov ebp,esp >>>>>>>>>>>>>>>>>>> [000012ea](03)  8b4508          mov eax,[ebp+08] >>>>>>>>>>>>>>>>>>> [000012ed](01)  50              push eax >>>>>>>>>>>>>>>>>>> [000012ee](03)  8b4d08          mov ecx,[ebp+08] >>>>>>>>>>>>>>>>>>> [000012f1](01)  51              push ecx >>>>>>>>>>>>>>>>>>> [000012f2](05)  e880feffff      call 00001177 // call H
    [000012f7](03)  83c408          add esp,+08 >>>>>>>>>>>>>>>>>>> [000012fa](02)  85c0            test eax,eax >>>>>>>>>>>>>>>>>>> [000012fc](02)  7402            jz 00001300 >>>>>>>>>>>>>>>>>>> [000012fe](02)  ebfe            jmp 000012fe >>>>>>>>>>>>>>>>>>> [00001300](01)  5d              pop ebp >>>>>>>>>>>>>>>>>>> [00001301](01)  c3              ret >>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [00001301]

    _main()
    [00001307](01)  55              push ebp >>>>>>>>>>>>>>>>>>> [00001308](02)  8bec            mov ebp,esp >>>>>>>>>>>>>>>>>>> [0000130a](05)  68e7120000      push 000012e7 // push P
    [0000130f](05)  e8d3ffffff      call 000012e7 // call P
    [00001314](03)  83c404          add esp,+04 >>>>>>>>>>>>>>>>>>> [00001317](02)  33c0            xor eax,eax >>>>>>>>>>>>>>>>>>> [00001319](01)  5d              pop ebp >>>>>>>>>>>>>>>>>>> [0000131a](01)  c3              ret >>>>>>>>>>>>>>>>>>> Size in bytes:(0020) [0000131a]

        machine   stack     stack     machine    assembly
        address   address   data      code       language
        ========  ========  ========  ========= >>>>>>>>>>>>>>>>>>> =============
    [00001307][00102190][00000000] 55         push ebp >>>>>>>>>>>>>>>>>>> [00001308][00102190][00000000] 8bec       mov ebp,esp >>>>>>>>>>>>>>>>>>> [0000130a][0010218c][000012e7] 68e7120000 push >>>>>>>>>>>>>>>>>>> 000012e7 //
    push P [0000130f][00102188][00001314] e8d3ffffff call >>>>>>>>>>>>>>>>>>> 000012e7
    // call P [000012e7][00102184][00102190] 55 push ebp >>>>>>>>>>>>>>>>>>>     // enter executed P
    [000012e8][00102184][00102190] 8bec       mov ebp,esp >>>>>>>>>>>>>>>>>>> [000012ea][00102184][00102190] 8b4508     mov >>>>>>>>>>>>>>>>>>> eax,[ebp+08]
    [000012ed][00102180][000012e7] 50         push >>>>>>>>>>>>>>>>>>> eax      //
    push P [000012ee][00102180][000012e7] 8b4d08     mov >>>>>>>>>>>>>>>>>>> ecx,[ebp+08] [000012f1][0010217c][000012e7] 51 push >>>>>>>>>>>>>>>>>>> ecx      // push P [000012f2][00102178][000012f7] >>>>>>>>>>>>>>>>>>> e880feffff
    call 00001177 // call H

    Begin Local Halt Decider Simulation   Execution Trace >>>>>>>>>>>>>>>>>>> Stored
    at:212244 [000012e7][00212230][00212234] 55 push ebp >>>>>>>>>>>>>>>>>>>     // enter emulated P
    [000012e8][00212230][00212234] 8bec        mov ebp,esp
    [000012ea][00212230][00212234] 8b4508      mov >>>>>>>>>>>>>>>>>>> eax,[ebp+08]
    [000012ed][0021222c][000012e7] 50          push >>>>>>>>>>>>>>>>>>> eax      //
    push P [000012ee][0021222c][000012e7] 8b4d08      mov >>>>>>>>>>>>>>>>>>> ecx,[ebp+08] [000012f1][00212228][000012e7] 51 push >>>>>>>>>>>>>>>>>>> ecx      // push P [000012f2][00212224][000012f7] >>>>>>>>>>>>>>>>>>> e880feffff
    call 00001177 // call H

    So, by what instruction reference manual is a call >>>>>>>>>>>>>>>>>> 00001177
    followedby the execution of the instruction at 000012e7. >>>>>>>>>>>>>>>>>>
    Your "CPU" is broken, or emulation incorrect. >>>>>>>>>>>>>>>>>>
    FAIL.
    [000012e7][0025cc58][0025cc5c] 55          push >>>>>>>>>>>>>>>>>>> ebp      //
    enter emulated P
    [000012e8][0025cc58][0025cc5c] 8bec        mov ebp,esp
    [000012ea][0025cc58][0025cc5c] 8b4508      mov >>>>>>>>>>>>>>>>>>> eax,[ebp+08]
    [000012ed][0025cc54][000012e7] 50          push >>>>>>>>>>>>>>>>>>> eax      //
    push P [000012ee][0025cc54][000012e7] 8b4d08      mov >>>>>>>>>>>>>>>>>>> ecx,[ebp+08] [000012f1][0025cc50][000012e7] 51 push >>>>>>>>>>>>>>>>>>> ecx      // push P [000012f2][0025cc4c][000012f7] >>>>>>>>>>>>>>>>>>> e880feffff
    call 00001177 // call H Local Halt Decider: Infinite >>>>>>>>>>>>>>>>>>> Recursion
    Detected Simulation Stopped

    It is completely obvious that when H(P,P) correctly >>>>>>>>>>>>>>>>>>> emulates
    its input that it must emulate the first seven >>>>>>>>>>>>>>>>>>> instructions of
    P. Because the seventh instruction of P repeats this >>>>>>>>>>>>>>>>>>> process we
    know with complete certainty that the correct and >>>>>>>>>>>>>>>>>>> complete
    emulation of P by H would never reach its final “ret” >>>>>>>>>>>>>>>>>>> instruction, thus never halts.

    Problem, the 7th intruction DOESN't "Just repeat the >>>>>>>>>>>>>>>>>> procedure",
    because that H always has the option to abort its >>>>>>>>>>>>>>>>>> simulation,
    just like this onne did, and return to its P and see >>>>>>>>>>>>>>>>>> it halt.
    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO >>>>>>>>>>>>>>>>> ACTUAL
    REBUTTAL AT ALL:

    The partial correct x86 emulation of the input to H(P,P) >>>>>>>>>>>>>>>>> conclusively proves that the complete and correct x86 >>>>>>>>>>>>>>>>> emulation
    would never stop running.


    You SAY that, but you don't answer the actual questions >>>>>>>>>>>>>>>> about HOW.

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO >>>>>>>>>>>>>>> EVIDENCE
    WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE THAT THE >>>>>>>>>>>>>>> CORRECT
    PARTIAL EMULATION OF THE INPUT TO H(P,P) CONCLUSIVELY >>>>>>>>>>>>>>> PROVES THAT
    THE CORRECT AND COMPLETE X86 EMULATION OF THE INPUT TO >>>>>>>>>>>>>>> H(P,P)
    WOULD NEVER STOP RUNNING.

    It is completely obvious that when H(P,P) correctly >>>>>>>>>>>>>>> emulates its
    input that it must emulate the first seven instructions >>>>>>>>>>>>>>> of P.
    Because the seventh instruction of P repeats this process >>>>>>>>>>>>>>> we know
    with complete certainty that the correct and complete >>>>>>>>>>>>>>> emulation of
    P by H would never reach its final “ret” instruction, >>>>>>>>>>>>>>> thus never
    halts.

    If P should have halted (i.e. no infinite loop) then your >>>>>>>>>>>>>> simulation
    detector, S (not H), gets the answer wrong.  You S is NOT >>>>>>>>>>>>>> a halting
    decider.

    /Flibble

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO ACTUAL >>>>>>>>>>>>> REBUTTAL AT ALL.

    _P()
    [00001352](01)  55              push ebp >>>>>>>>>>>>> [00001353](02)  8bec            mov ebp,esp >>>>>>>>>>>>> [00001355](03)  8b4508          mov eax,[ebp+08] >>>>>>>>>>>>> [00001358](01)  50              push eax      // push P
    [00001359](03)  8b4d08          mov ecx,[ebp+08] >>>>>>>>>>>>> [0000135c](01)  51              push ecx      // push P
    [0000135d](05)  e840feffff      call 000011a2 // call H >>>>>>>>>>>>> [00001362](03)  83c408          add esp,+08 >>>>>>>>>>>>> [00001365](02)  85c0            test eax,eax >>>>>>>>>>>>> [00001367](02)  7402            jz 0000136b >>>>>>>>>>>>> [00001369](02)  ebfe            jmp 00001369 >>>>>>>>>>>>> [0000136b](01)  5d              pop ebp >>>>>>>>>>>>> [0000136c](01)  c3              ret
    Size in bytes:(0027) [0000136c]

    It is completely obvious that when H(P,P) correctly
    emulates its
    input that it must emulate the first seven instructions of >>>>>>>>>>>>> P. Because
    the seventh instruction of P repeats this process we know with >>>>>>>>>>>>> complete certainty that the correct and complete emulation >>>>>>>>>>>>> of P by H
    would never reach its final “ret” instruction, thus never >>>>>>>>>>>>> halts.

    We are going around and around and around in circles. I will >>>>>>>>>>>> try again:

    If you replace the opcodes "EB FE" at 00001369 with the >>>>>>>>>>>> opcodes "90 90"
    then your H gets the answer wrong: P should have halted. >>>>>>>>>>>>
    /Flibble


    As I already said before this is merely your cluelessness >>>>>>>>>>> that when H(P,P) is invoked the correct x86 emulation of the >>>>>>>>>>> input to H(P,P) makes and code after [0000135d] unreachable. >>>>>>>>>>
    Wrong, because when that H return the value 0, it will get there. >>>>>>>>> Like I said people that are dumber than a box of rocks won't be >>>>>>>>> able to correctly understand this.

    When H(P,P) is invoked the correctly emulated input to H(P,P) >>>>>>>>> cannot possibly reach any instruction beyond [0000135d].

    So, you are defining that you H(P,P) never returns because it is >>>>>>>> caught in the infinite rcursion.

    Thats fine, just says it can't be the correctly answering
    decider you claim it to be.

    I have corrected you on this too many times.


    How. You need to define what H(P,P) actually does.

    I have explained that too many times.

    To understand that H(P,P)==0 is correct we only need to know that H
    performs a correct x86 emulation of its input and then examine the
    execution trace.

    And a CORRECT emulation of the code will Halt if H(P,P) returns 0,
    which it can only do if it does not actually do a correct emulation


    The correctly emulated input to H(P,P) never gets past its machine
    address [0000135d].



    Only if H actually doesn't return 0. Yes, H can't correctly return 0
    if it correctly emulates its input, but you can't drop that requirement.

    void P(u32 x)
    {
      if (H(x, x))
        HERE: goto HERE;
      return;
    }

    int main()
    {
      Output("Input_Halts = ", H((u32)P, (u32)P));
    }

    When H returns 0 it does not returns 0 to P it returns 0 to main().

    But it also return 0 to the computation P(P), maybe not the copy that it
    is simulating, since it aborts that before it get to it, but it will in
    the CORRECT SIMULATION of its input, which is the code of P with an
    input of the code of P, which IS P(P). (Remember, correct simluation
    don't abort, since programs don't just disappear).

    Until you can prove that H can have two different results for identical
    code running with identical inputs, which violates fundamental proofs in compuatation theory, you can't make that claim.

    You like to claim that this isn't true, and if you COULD prove it, that
    would make you famous, but you can't.

    To prove your assertion, what is the first x86 instruction in the
    operation of the H(P,P) called from main behaves differently then that
    exact same x86 instruction in the operation o the H(P,P) call from P(P),
    which generates a different resultant state.

    If there is no first difference, there can't be ANY difference if H(P,P)
    is a finite compuatiom, and thus H(P,P) does return 0 to P(P).

    Go on, show your proof and make yourself famous, or show you have just
    been lying (or stupid) and just ignoring this fundamental property of Computations.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Richard Damon on Thu Jun 9 17:09:08 2022
    XPost: comp.theory, sci.logic, sci.math

    On 6/9/2022 4:54 PM, Richard Damon wrote:
    On 6/9/22 5:29 PM, olcott wrote:
    On 6/9/2022 4:13 PM, Richard Damon wrote:

    On 6/9/22 5:00 PM, olcott wrote:
    On 6/9/2022 3:25 PM, Richard Damon wrote:
    On 6/9/22 4:13 PM, olcott wrote:
    On 6/9/2022 2:57 PM, Richard Damon wrote:
    On 6/9/22 3:52 PM, olcott wrote:
    On 6/9/2022 2:38 PM, Richard Damon wrote:

    On 6/9/22 3:26 PM, olcott wrote:
    On 6/9/2022 1:12 PM, Richard Damon wrote:
    On 6/9/22 1:55 PM, olcott wrote:
    On 6/9/2022 12:46 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:39:32 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 12:28 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:15:24 -0500
    olcott <NoOne@NoWhere.com> wrote:
    On 6/9/2022 12:06 PM, Richard Damon wrote:
    On 6/9/22 12:54 PM, olcott wrote:
    On 6/9/2022 11:34 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 6/9/22 11:47 AM, olcott wrote:
    void P(u32 x)
    {
         if (H(x, x))
           HERE: goto HERE;
         return;
    }

    int main()
    {
         P(P);
    }

    _P()
    [000012e7](01)  55              push ebp >>>>>>>>>>>>>>>>>>>> [000012e8](02)  8bec            mov ebp,esp >>>>>>>>>>>>>>>>>>>> [000012ea](03)  8b4508          mov eax,[ebp+08] >>>>>>>>>>>>>>>>>>>> [000012ed](01)  50              push eax >>>>>>>>>>>>>>>>>>>> [000012ee](03)  8b4d08          mov ecx,[ebp+08] >>>>>>>>>>>>>>>>>>>> [000012f1](01)  51              push ecx >>>>>>>>>>>>>>>>>>>> [000012f2](05)  e880feffff      call 00001177 // call H
    [000012f7](03)  83c408          add esp,+08 >>>>>>>>>>>>>>>>>>>> [000012fa](02)  85c0            test eax,eax >>>>>>>>>>>>>>>>>>>> [000012fc](02)  7402            jz 00001300 >>>>>>>>>>>>>>>>>>>> [000012fe](02)  ebfe            jmp 000012fe >>>>>>>>>>>>>>>>>>>> [00001300](01)  5d              pop ebp >>>>>>>>>>>>>>>>>>>> [00001301](01)  c3              ret >>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [00001301]

    _main()
    [00001307](01)  55              push ebp >>>>>>>>>>>>>>>>>>>> [00001308](02)  8bec            mov ebp,esp >>>>>>>>>>>>>>>>>>>> [0000130a](05)  68e7120000      push 000012e7 // push P
    [0000130f](05)  e8d3ffffff      call 000012e7 // call P
    [00001314](03)  83c404          add esp,+04 >>>>>>>>>>>>>>>>>>>> [00001317](02)  33c0            xor eax,eax >>>>>>>>>>>>>>>>>>>> [00001319](01)  5d              pop ebp >>>>>>>>>>>>>>>>>>>> [0000131a](01)  c3              ret >>>>>>>>>>>>>>>>>>>> Size in bytes:(0020) [0000131a]

        machine   stack     stack     machine    assembly
        address   address   data      code       language
        ========  ========  ========  ========= >>>>>>>>>>>>>>>>>>>> =============
    [00001307][00102190][00000000] 55         push ebp >>>>>>>>>>>>>>>>>>>> [00001308][00102190][00000000] 8bec       mov ebp,esp
    [0000130a][0010218c][000012e7] 68e7120000 push >>>>>>>>>>>>>>>>>>>> 000012e7 //
    push P [0000130f][00102188][00001314] e8d3ffffff >>>>>>>>>>>>>>>>>>>> call 000012e7
    // call P [000012e7][00102184][00102190] 55 push ebp >>>>>>>>>>>>>>>>>>>>     // enter executed P
    [000012e8][00102184][00102190] 8bec       mov ebp,esp
    [000012ea][00102184][00102190] 8b4508     mov >>>>>>>>>>>>>>>>>>>> eax,[ebp+08]
    [000012ed][00102180][000012e7] 50         push >>>>>>>>>>>>>>>>>>>> eax      //
    push P [000012ee][00102180][000012e7] 8b4d08     mov >>>>>>>>>>>>>>>>>>>> ecx,[ebp+08] [000012f1][0010217c][000012e7] 51 push >>>>>>>>>>>>>>>>>>>> ecx      // push P [000012f2][00102178][000012f7] >>>>>>>>>>>>>>>>>>>> e880feffff
    call 00001177 // call H

    Begin Local Halt Decider Simulation   Execution >>>>>>>>>>>>>>>>>>>> Trace Stored
    at:212244 [000012e7][00212230][00212234] 55 push ebp >>>>>>>>>>>>>>>>>>>>     // enter emulated P
    [000012e8][00212230][00212234] 8bec        mov ebp,esp
    [000012ea][00212230][00212234] 8b4508      mov >>>>>>>>>>>>>>>>>>>> eax,[ebp+08]
    [000012ed][0021222c][000012e7] 50          push >>>>>>>>>>>>>>>>>>>> eax      //
    push P [000012ee][0021222c][000012e7] 8b4d08      mov >>>>>>>>>>>>>>>>>>>> ecx,[ebp+08] [000012f1][00212228][000012e7] 51 push >>>>>>>>>>>>>>>>>>>> ecx      // push P [000012f2][00212224][000012f7] >>>>>>>>>>>>>>>>>>>> e880feffff
    call 00001177 // call H

    So, by what instruction reference manual is a call >>>>>>>>>>>>>>>>>>> 00001177
    followedby the execution of the instruction at 000012e7. >>>>>>>>>>>>>>>>>>>
    Your "CPU" is broken, or emulation incorrect. >>>>>>>>>>>>>>>>>>>
    FAIL.
    [000012e7][0025cc58][0025cc5c] 55          push >>>>>>>>>>>>>>>>>>>> ebp      //
    enter emulated P
    [000012e8][0025cc58][0025cc5c] 8bec        mov ebp,esp
    [000012ea][0025cc58][0025cc5c] 8b4508      mov >>>>>>>>>>>>>>>>>>>> eax,[ebp+08]
    [000012ed][0025cc54][000012e7] 50          push >>>>>>>>>>>>>>>>>>>> eax      //
    push P [000012ee][0025cc54][000012e7] 8b4d08      mov >>>>>>>>>>>>>>>>>>>> ecx,[ebp+08] [000012f1][0025cc50][000012e7] 51 push >>>>>>>>>>>>>>>>>>>> ecx      // push P [000012f2][0025cc4c][000012f7] >>>>>>>>>>>>>>>>>>>> e880feffff
    call 00001177 // call H Local Halt Decider: Infinite >>>>>>>>>>>>>>>>>>>> Recursion
    Detected Simulation Stopped

    It is completely obvious that when H(P,P) correctly >>>>>>>>>>>>>>>>>>>> emulates
    its input that it must emulate the first seven >>>>>>>>>>>>>>>>>>>> instructions of
    P. Because the seventh instruction of P repeats this >>>>>>>>>>>>>>>>>>>> process we
    know with complete certainty that the correct and >>>>>>>>>>>>>>>>>>>> complete
    emulation of P by H would never reach its final “ret” >>>>>>>>>>>>>>>>>>>> instruction, thus never halts.

    Problem, the 7th intruction DOESN't "Just repeat the >>>>>>>>>>>>>>>>>>> procedure",
    because that H always has the option to abort its >>>>>>>>>>>>>>>>>>> simulation,
    just like this onne did, and return to its P and see >>>>>>>>>>>>>>>>>>> it halt.
    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS >>>>>>>>>>>>>>>>>> NO ACTUAL
    REBUTTAL AT ALL:

    The partial correct x86 emulation of the input to H(P,P) >>>>>>>>>>>>>>>>>> conclusively proves that the complete and correct x86 >>>>>>>>>>>>>>>>>> emulation
    would never stop running.


    You SAY that, but you don't answer the actual questions >>>>>>>>>>>>>>>>> about HOW.

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO >>>>>>>>>>>>>>>> EVIDENCE
    WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE THAT THE >>>>>>>>>>>>>>>> CORRECT
    PARTIAL EMULATION OF THE INPUT TO H(P,P) CONCLUSIVELY >>>>>>>>>>>>>>>> PROVES THAT
    THE CORRECT AND COMPLETE X86 EMULATION OF THE INPUT TO >>>>>>>>>>>>>>>> H(P,P)
    WOULD NEVER STOP RUNNING.

    It is completely obvious that when H(P,P) correctly >>>>>>>>>>>>>>>> emulates its
    input that it must emulate the first seven instructions >>>>>>>>>>>>>>>> of P.
    Because the seventh instruction of P repeats this >>>>>>>>>>>>>>>> process we know
    with complete certainty that the correct and complete >>>>>>>>>>>>>>>> emulation of
    P by H would never reach its final “ret” instruction, >>>>>>>>>>>>>>>> thus never
    halts.

    If P should have halted (i.e. no infinite loop) then your >>>>>>>>>>>>>>> simulation
    detector, S (not H), gets the answer wrong.  You S is NOT >>>>>>>>>>>>>>> a halting
    decider.

    /Flibble

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO >>>>>>>>>>>>>> ACTUAL
    REBUTTAL AT ALL.

    _P()
    [00001352](01)  55              push ebp >>>>>>>>>>>>>> [00001353](02)  8bec            mov ebp,esp >>>>>>>>>>>>>> [00001355](03)  8b4508          mov eax,[ebp+08] >>>>>>>>>>>>>> [00001358](01)  50              push eax      // push P
    [00001359](03)  8b4d08          mov ecx,[ebp+08] >>>>>>>>>>>>>> [0000135c](01)  51              push ecx      // push P
    [0000135d](05)  e840feffff      call 000011a2 // call H >>>>>>>>>>>>>> [00001362](03)  83c408          add esp,+08 >>>>>>>>>>>>>> [00001365](02)  85c0            test eax,eax >>>>>>>>>>>>>> [00001367](02)  7402            jz 0000136b >>>>>>>>>>>>>> [00001369](02)  ebfe            jmp 00001369 >>>>>>>>>>>>>> [0000136b](01)  5d              pop ebp >>>>>>>>>>>>>> [0000136c](01)  c3              ret
    Size in bytes:(0027) [0000136c]

    It is completely obvious that when H(P,P) correctly >>>>>>>>>>>>>> emulates its
    input that it must emulate the first seven instructions of >>>>>>>>>>>>>> P. Because
    the seventh instruction of P repeats this process we know >>>>>>>>>>>>>> with
    complete certainty that the correct and complete emulation >>>>>>>>>>>>>> of P by H
    would never reach its final “ret” instruction, thus never >>>>>>>>>>>>>> halts.

    We are going around and around and around in circles. I >>>>>>>>>>>>> will try again:

    If you replace the opcodes "EB FE" at 00001369 with the >>>>>>>>>>>>> opcodes "90 90"
    then your H gets the answer wrong: P should have halted. >>>>>>>>>>>>>
    /Flibble


    As I already said before this is merely your cluelessness >>>>>>>>>>>> that when H(P,P) is invoked the correct x86 emulation of the >>>>>>>>>>>> input to H(P,P) makes and code after [0000135d] unreachable. >>>>>>>>>>>
    Wrong, because when that H return the value 0, it will get >>>>>>>>>>> there.
    Like I said people that are dumber than a box of rocks won't >>>>>>>>>> be able to correctly understand this.

    When H(P,P) is invoked the correctly emulated input to H(P,P) >>>>>>>>>> cannot possibly reach any instruction beyond [0000135d].

    So, you are defining that you H(P,P) never returns because it >>>>>>>>> is caught in the infinite rcursion.

    Thats fine, just says it can't be the correctly answering
    decider you claim it to be.

    I have corrected you on this too many times.


    How. You need to define what H(P,P) actually does.

    I have explained that too many times.

    To understand that H(P,P)==0 is correct we only need to know that
    H performs a correct x86 emulation of its input and then examine
    the execution trace.

    And a CORRECT emulation of the code will Halt if H(P,P) returns 0,
    which it can only do if it does not actually do a correct emulation


    The correctly emulated input to H(P,P) never gets past its machine
    address [0000135d].



    Only if H actually doesn't return 0. Yes, H can't correctly return 0
    if it correctly emulates its input, but you can't drop that requirement.

    void P(u32 x)
    {
       if (H(x, x))
         HERE: goto HERE;
       return;
    }

    int main()
    {
       Output("Input_Halts = ", H((u32)P, (u32)P));
    }

    When H returns 0 it does not returns 0 to P it returns 0 to main().

    But it also return 0 to the computation P(P), maybe not the copy that it
    is simulating, since it aborts that before it get to it,

    Finally you are not stupid or deceptive.



    --
    Copyright 2022 Pete Olcott

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

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mr Flibble@21:1/5 to olcott on Thu Jun 9 23:15:24 2022
    XPost: comp.theory, sci.logic, sci.math

    On Thu, 9 Jun 2022 17:09:08 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 4:54 PM, Richard Damon wrote:
    On 6/9/22 5:29 PM, olcott wrote:
    On 6/9/2022 4:13 PM, Richard Damon wrote:

    On 6/9/22 5:00 PM, olcott wrote:
    On 6/9/2022 3:25 PM, Richard Damon wrote:
    On 6/9/22 4:13 PM, olcott wrote:
    On 6/9/2022 2:57 PM, Richard Damon wrote:
    On 6/9/22 3:52 PM, olcott wrote:
    On 6/9/2022 2:38 PM, Richard Damon wrote:

    On 6/9/22 3:26 PM, olcott wrote:
    On 6/9/2022 1:12 PM, Richard Damon wrote:
    On 6/9/22 1:55 PM, olcott wrote:
    On 6/9/2022 12:46 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:39:32 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 12:28 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:15:24 -0500
    olcott <NoOne@NoWhere.com> wrote:
    On 6/9/2022 12:06 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>> On 6/9/22 12:54 PM, olcott wrote:
    On 6/9/2022 11:34 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 6/9/22 11:47 AM, olcott wrote:
    void P(u32 x)
    {
         if (H(x, x))
           HERE: goto HERE;
         return;
    }

    int main()
    {
         P(P);
    }

    _P()
    [000012e7](01)  55              push ebp >>>>>>>>>>>>>>>>>>>> [000012e8](02)  8bec            mov ebp,esp >>>>>>>>>>>>>>>>>>>> [000012ea](03)  8b4508          mov eax,[ebp+08]
    [000012ed](01)  50              push eax >>>>>>>>>>>>>>>>>>>> [000012ee](03)  8b4d08          mov ecx,[ebp+08]
    [000012f1](01)  51              push ecx >>>>>>>>>>>>>>>>>>>> [000012f2](05)  e880feffff      call 00001177 // >>>>>>>>>>>>>>>>>>>> call H [000012f7](03)  83c408          add >>>>>>>>>>>>>>>>>>>> esp,+08 [000012fa](02)  85c0            test >>>>>>>>>>>>>>>>>>>> eax,eax [000012fc](02)  7402            jz >>>>>>>>>>>>>>>>>>>> 00001300 [000012fe](02)  ebfe            jmp >>>>>>>>>>>>>>>>>>>> 000012fe [00001300](01)  5d              pop ebp
    [00001301](01)  c3              ret >>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [00001301]

    _main()
    [00001307](01)  55              push ebp >>>>>>>>>>>>>>>>>>>> [00001308](02)  8bec            mov ebp,esp >>>>>>>>>>>>>>>>>>>> [0000130a](05)  68e7120000      push 000012e7 // >>>>>>>>>>>>>>>>>>>> push P [0000130f](05)  e8d3ffffff      call >>>>>>>>>>>>>>>>>>>> 000012e7 // call P [00001314](03)  83c404 >>>>>>>>>>>>>>>>>>>>   add esp,+04 [00001317](02)  33c0 >>>>>>>>>>>>>>>>>>>> xor eax,eax [00001319](01)  5d              pop
    ebp [0000131a](01)  c3              ret >>>>>>>>>>>>>>>>>>>> Size in bytes:(0020) [0000131a]

        machine   stack     stack     machine >>>>>>>>>>>>>>>>>>>> assembly address   address   data      code >>>>>>>>>>>>>>>>>>>> language ========  ========  ======== >>>>>>>>>>>>>>>>>>>> ========= =============
    [00001307][00102190][00000000] 55         push >>>>>>>>>>>>>>>>>>>> ebp [00001308][00102190][00000000] 8bec >>>>>>>>>>>>>>>>>>>> mov ebp,esp [0000130a][0010218c][000012e7] >>>>>>>>>>>>>>>>>>>> 68e7120000 push 000012e7 //
    push P [0000130f][00102188][00001314] e8d3ffffff >>>>>>>>>>>>>>>>>>>> call 000012e7
    // call P [000012e7][00102184][00102190] 55 push >>>>>>>>>>>>>>>>>>>> ebp // enter executed P
    [000012e8][00102184][00102190] 8bec       mov >>>>>>>>>>>>>>>>>>>> ebp,esp [000012ea][00102184][00102190] 8b4508 >>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08]
    [000012ed][00102180][000012e7] 50         push >>>>>>>>>>>>>>>>>>>> eax      //
    push P [000012ee][00102180][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08] [000012f1][0010217c][000012e7] >>>>>>>>>>>>>>>>>>>> 51 push ecx      // push P
    [000012f2][00102178][000012f7] e880feffff >>>>>>>>>>>>>>>>>>>> call 00001177 // call H

    Begin Local Halt Decider Simulation   Execution >>>>>>>>>>>>>>>>>>>> Trace Stored
    at:212244 [000012e7][00212230][00212234] 55 push >>>>>>>>>>>>>>>>>>>> ebp // enter emulated P
    [000012e8][00212230][00212234] 8bec        mov >>>>>>>>>>>>>>>>>>>> ebp,esp [000012ea][00212230][00212234] 8b4508 >>>>>>>>>>>>>>>>>>>>   mov eax,[ebp+08]
    [000012ed][0021222c][000012e7] 50          push
    eax      //
    push P [000012ee][0021222c][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08] [000012f1][00212228][000012e7] >>>>>>>>>>>>>>>>>>>> 51 push ecx      // push P
    [000012f2][00212224][000012f7] e880feffff >>>>>>>>>>>>>>>>>>>> call 00001177 // call H

    So, by what instruction reference manual is a >>>>>>>>>>>>>>>>>>> call 00001177
    followedby the execution of the instruction at >>>>>>>>>>>>>>>>>>> 000012e7.

    Your "CPU" is broken, or emulation incorrect. >>>>>>>>>>>>>>>>>>>
    FAIL.
    [000012e7][0025cc58][0025cc5c] 55          push
    ebp      //
    enter emulated P
    [000012e8][0025cc58][0025cc5c] 8bec        mov >>>>>>>>>>>>>>>>>>>> ebp,esp [000012ea][0025cc58][0025cc5c] 8b4508 >>>>>>>>>>>>>>>>>>>>   mov eax,[ebp+08]
    [000012ed][0025cc54][000012e7] 50          push
    eax      //
    push P [000012ee][0025cc54][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08] [000012f1][0025cc50][000012e7] >>>>>>>>>>>>>>>>>>>> 51 push ecx      // push P
    [000012f2][0025cc4c][000012f7] e880feffff >>>>>>>>>>>>>>>>>>>> call 00001177 // call H Local Halt Decider: >>>>>>>>>>>>>>>>>>>> Infinite Recursion
    Detected Simulation Stopped

    It is completely obvious that when H(P,P) >>>>>>>>>>>>>>>>>>>> correctly emulates
    its input that it must emulate the first seven >>>>>>>>>>>>>>>>>>>> instructions of
    P. Because the seventh instruction of P repeats >>>>>>>>>>>>>>>>>>>> this process we
    know with complete certainty that the correct >>>>>>>>>>>>>>>>>>>> and complete
    emulation of P by H would never reach its final >>>>>>>>>>>>>>>>>>>> “ret” instruction, thus never halts. >>>>>>>>>>>>>>>>>>>
    Problem, the 7th intruction DOESN't "Just repeat >>>>>>>>>>>>>>>>>>> the procedure",
    because that H always has the option to abort its >>>>>>>>>>>>>>>>>>> simulation,
    just like this onne did, and return to its P and >>>>>>>>>>>>>>>>>>> see it halt.
    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS >>>>>>>>>>>>>>>>>> IS NO ACTUAL
    REBUTTAL AT ALL:

    The partial correct x86 emulation of the input to >>>>>>>>>>>>>>>>>> H(P,P) conclusively proves that the complete and >>>>>>>>>>>>>>>>>> correct x86 emulation
    would never stop running.


    You SAY that, but you don't answer the actual >>>>>>>>>>>>>>>>> questions about HOW.

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS >>>>>>>>>>>>>>>> NO EVIDENCE
    WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE THAT >>>>>>>>>>>>>>>> THE CORRECT
    PARTIAL EMULATION OF THE INPUT TO H(P,P)
    CONCLUSIVELY PROVES THAT
    THE CORRECT AND COMPLETE X86 EMULATION OF THE INPUT >>>>>>>>>>>>>>>> TO H(P,P)
    WOULD NEVER STOP RUNNING.

    It is completely obvious that when H(P,P) correctly >>>>>>>>>>>>>>>> emulates its
    input that it must emulate the first seven
    instructions of P.
    Because the seventh instruction of P repeats this >>>>>>>>>>>>>>>> process we know
    with complete certainty that the correct and >>>>>>>>>>>>>>>> complete emulation of
    P by H would never reach its final “ret” >>>>>>>>>>>>>>>> instruction, thus never
    halts.

    If P should have halted (i.e. no infinite loop) then >>>>>>>>>>>>>>> your simulation
    detector, S (not H), gets the answer wrong.  You S is >>>>>>>>>>>>>>> NOT a halting
    decider.

    /Flibble

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS >>>>>>>>>>>>>> NO ACTUAL
    REBUTTAL AT ALL.

    _P()
    [00001352](01)  55              push ebp >>>>>>>>>>>>>> [00001353](02)  8bec            mov ebp,esp >>>>>>>>>>>>>> [00001355](03)  8b4508          mov eax,[ebp+08] >>>>>>>>>>>>>> [00001358](01)  50              push eax      // push P
    [00001359](03)  8b4d08          mov ecx,[ebp+08] >>>>>>>>>>>>>> [0000135c](01)  51              push ecx      // push P
    [0000135d](05)  e840feffff      call 000011a2 // call H >>>>>>>>>>>>>> [00001362](03)  83c408          add esp,+08 >>>>>>>>>>>>>> [00001365](02)  85c0            test eax,eax >>>>>>>>>>>>>> [00001367](02)  7402            jz 0000136b >>>>>>>>>>>>>> [00001369](02)  ebfe            jmp 00001369 >>>>>>>>>>>>>> [0000136b](01)  5d              pop ebp >>>>>>>>>>>>>> [0000136c](01)  c3              ret >>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]

    It is completely obvious that when H(P,P) correctly >>>>>>>>>>>>>> emulates its
    input that it must emulate the first seven
    instructions of P. Because
    the seventh instruction of P repeats this process we >>>>>>>>>>>>>> know with
    complete certainty that the correct and complete >>>>>>>>>>>>>> emulation of P by H
    would never reach its final “ret” instruction, thus >>>>>>>>>>>>>> never halts.

    We are going around and around and around in circles. I >>>>>>>>>>>>> will try again:

    If you replace the opcodes "EB FE" at 00001369 with the >>>>>>>>>>>>> opcodes "90 90"
    then your H gets the answer wrong: P should have halted. >>>>>>>>>>>>>
    /Flibble


    As I already said before this is merely your
    cluelessness that when H(P,P) is invoked the correct x86 >>>>>>>>>>>> emulation of the input to H(P,P) makes and code after >>>>>>>>>>>> [0000135d] unreachable.

    Wrong, because when that H return the value 0, it will >>>>>>>>>>> get there.
    Like I said people that are dumber than a box of rocks
    won't be able to correctly understand this.

    When H(P,P) is invoked the correctly emulated input to
    H(P,P) cannot possibly reach any instruction beyond
    [0000135d].

    So, you are defining that you H(P,P) never returns because >>>>>>>>> it is caught in the infinite rcursion.

    Thats fine, just says it can't be the correctly answering >>>>>>>>> decider you claim it to be.

    I have corrected you on this too many times.


    How. You need to define what H(P,P) actually does.

    I have explained that too many times.

    To understand that H(P,P)==0 is correct we only need to know
    that H performs a correct x86 emulation of its input and then
    examine the execution trace.

    And a CORRECT emulation of the code will Halt if H(P,P) returns
    0, which it can only do if it does not actually do a correct
    emulation

    The correctly emulated input to H(P,P) never gets past its
    machine address [0000135d].



    Only if H actually doesn't return 0. Yes, H can't correctly
    return 0 if it correctly emulates its input, but you can't drop
    that requirement.

    void P(u32 x)
    {
       if (H(x, x))
         HERE: goto HERE;
       return;
    }

    int main()
    {
       Output("Input_Halts = ", H((u32)P, (u32)P));
    }

    When H returns 0 it does not returns 0 to P it returns 0 to
    main().

    But it also return 0 to the computation P(P), maybe not the copy
    that it is simulating, since it aborts that before it get to it,

    Finally you are not stupid or deceptive.

    If H never returns a value to P then H is not a halting decider; if H
    returns a value of 0 to main() when P halts then H is not a halting
    decider.

    H is not a halting decider; H is a simulation detector, S.

    /Flibble

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mr Flibble@21:1/5 to olcott on Thu Jun 9 23:27:12 2022
    XPost: comp.theory, sci.logic, sci.math

    On Thu, 9 Jun 2022 17:18:38 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 5:15 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:09:08 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 4:54 PM, Richard Damon wrote:
    On 6/9/22 5:29 PM, olcott wrote:
    On 6/9/2022 4:13 PM, Richard Damon wrote:

    On 6/9/22 5:00 PM, olcott wrote:
    On 6/9/2022 3:25 PM, Richard Damon wrote:
    On 6/9/22 4:13 PM, olcott wrote:
    On 6/9/2022 2:57 PM, Richard Damon wrote:
    On 6/9/22 3:52 PM, olcott wrote:
    On 6/9/2022 2:38 PM, Richard Damon wrote:

    On 6/9/22 3:26 PM, olcott wrote:
    On 6/9/2022 1:12 PM, Richard Damon wrote:
    On 6/9/22 1:55 PM, olcott wrote:
    On 6/9/2022 12:46 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:39:32 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 12:28 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:15:24 -0500
    olcott <NoOne@NoWhere.com> wrote:
    On 6/9/2022 12:06 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 6/9/22 12:54 PM, olcott wrote:
    On 6/9/2022 11:34 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 6/9/22 11:47 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>> void P(u32 x)
    {
         if (H(x, x))
           HERE: goto HERE;
         return;
    }

    int main()
    {
         P(P);
    }

    _P()
    [000012e7](01)  55              push ebp >>>>>>>>>>>>>>>>>>>>>> [000012e8](02)  8bec            mov ebp,esp
    [000012ea](03)  8b4508          mov >>>>>>>>>>>>>>>>>>>>>> eax,[ebp+08] [000012ed](01)  50 >>>>>>>>>>>>>>>>>>>>>> push eax [000012ee](03)  8b4d08          mov >>>>>>>>>>>>>>>>>>>>>> ecx,[ebp+08] [000012f1](01)  51 >>>>>>>>>>>>>>>>>>>>>> push ecx [000012f2](05)  e880feffff      call >>>>>>>>>>>>>>>>>>>>>> 00001177 // call H [000012f7](03)  83c408 >>>>>>>>>>>>>>>>>>>>>>     add esp,+08 [000012fa](02)  85c0 >>>>>>>>>>>>>>>>>>>>>> test eax,eax [000012fc](02)  7402 >>>>>>>>>>>>>>>>>>>>>> jz 00001300 [000012fe](02)  ebfe            jmp
    000012fe [00001300](01)  5d              pop
    ebp [00001301](01)  c3              ret >>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [00001301]

    _main()
    [00001307](01)  55              push ebp >>>>>>>>>>>>>>>>>>>>>> [00001308](02)  8bec            mov ebp,esp
    [0000130a](05)  68e7120000      push 000012e7 >>>>>>>>>>>>>>>>>>>>>> // push P [0000130f](05)  e8d3ffffff      call >>>>>>>>>>>>>>>>>>>>>> 000012e7 // call P [00001314](03)  83c404 >>>>>>>>>>>>>>>>>>>>>>   add esp,+04 [00001317](02)  33c0 >>>>>>>>>>>>>>>>>>>>>> xor eax,eax [00001319](01)  5d              pop
    ebp [0000131a](01)  c3              ret >>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0020) [0000131a]

        machine   stack     stack     machine
    assembly address   address   data      code >>>>>>>>>>>>>>>>>>>>>> language ========  ========  ======== >>>>>>>>>>>>>>>>>>>>>> ========= =============
    [00001307][00102190][00000000] 55         push >>>>>>>>>>>>>>>>>>>>>> ebp [00001308][00102190][00000000] 8bec >>>>>>>>>>>>>>>>>>>>>> mov ebp,esp [0000130a][0010218c][000012e7] >>>>>>>>>>>>>>>>>>>>>> 68e7120000 push 000012e7 //
    push P [0000130f][00102188][00001314] >>>>>>>>>>>>>>>>>>>>>> e8d3ffffff call 000012e7
    // call P [000012e7][00102184][00102190] 55 >>>>>>>>>>>>>>>>>>>>>> push ebp // enter executed P
    [000012e8][00102184][00102190] 8bec       mov >>>>>>>>>>>>>>>>>>>>>> ebp,esp [000012ea][00102184][00102190] 8b4508 >>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08]
    [000012ed][00102180][000012e7] 50         push >>>>>>>>>>>>>>>>>>>>>> eax      //
    push P [000012ee][00102180][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08] [000012f1][0010217c][000012e7] >>>>>>>>>>>>>>>>>>>>>> 51 push ecx      // push P
    [000012f2][00102178][000012f7] e880feffff >>>>>>>>>>>>>>>>>>>>>> call 00001177 // call H

    Begin Local Halt Decider Simulation   Execution >>>>>>>>>>>>>>>>>>>>>> Trace Stored
    at:212244 [000012e7][00212230][00212234] 55 >>>>>>>>>>>>>>>>>>>>>> push ebp // enter emulated P
    [000012e8][00212230][00212234] 8bec        mov >>>>>>>>>>>>>>>>>>>>>> ebp,esp [000012ea][00212230][00212234] 8b4508 >>>>>>>>>>>>>>>>>>>>>>   mov eax,[ebp+08]
    [000012ed][0021222c][000012e7] 50          push
    eax      //
    push P [000012ee][0021222c][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08]
    [000012f1][00212228][000012e7] 51 push ecx >>>>>>>>>>>>>>>>>>>>>> // push P [000012f2][00212224][000012f7] >>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H >>>>>>>>>>>>>>>>>>>>>
    So, by what instruction reference manual is a >>>>>>>>>>>>>>>>>>>>> call 00001177
    followedby the execution of the instruction at >>>>>>>>>>>>>>>>>>>>> 000012e7.

    Your "CPU" is broken, or emulation incorrect. >>>>>>>>>>>>>>>>>>>>>
    FAIL.
    [000012e7][0025cc58][0025cc5c] 55          push
    ebp      //
    enter emulated P
    [000012e8][0025cc58][0025cc5c] 8bec        mov >>>>>>>>>>>>>>>>>>>>>> ebp,esp [000012ea][0025cc58][0025cc5c] 8b4508 >>>>>>>>>>>>>>>>>>>>>>   mov eax,[ebp+08]
    [000012ed][0025cc54][000012e7] 50          push
    eax      //
    push P [000012ee][0025cc54][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08]
    [000012f1][0025cc50][000012e7] 51 push ecx >>>>>>>>>>>>>>>>>>>>>> // push P [000012f2][0025cc4c][000012f7] >>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H Local Halt >>>>>>>>>>>>>>>>>>>>>> Decider: Infinite Recursion
    Detected Simulation Stopped

    It is completely obvious that when H(P,P) >>>>>>>>>>>>>>>>>>>>>> correctly emulates
    its input that it must emulate the first seven >>>>>>>>>>>>>>>>>>>>>> instructions of
    P. Because the seventh instruction of P repeats >>>>>>>>>>>>>>>>>>>>>> this process we
    know with complete certainty that the correct >>>>>>>>>>>>>>>>>>>>>> and complete
    emulation of P by H would never reach its final >>>>>>>>>>>>>>>>>>>>>> “ret” instruction, thus never halts. >>>>>>>>>>>>>>>>>>>>>
    Problem, the 7th intruction DOESN't "Just repeat >>>>>>>>>>>>>>>>>>>>> the procedure",
    because that H always has the option to abort >>>>>>>>>>>>>>>>>>>>> its simulation,
    just like this onne did, and return to its P and >>>>>>>>>>>>>>>>>>>>> see it halt.
    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS >>>>>>>>>>>>>>>>>>>> IS NO ACTUAL
    REBUTTAL AT ALL:

    The partial correct x86 emulation of the input to >>>>>>>>>>>>>>>>>>>> H(P,P) conclusively proves that the complete and >>>>>>>>>>>>>>>>>>>> correct x86 emulation
    would never stop running.


    You SAY that, but you don't answer the actual >>>>>>>>>>>>>>>>>>> questions about HOW.

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS >>>>>>>>>>>>>>>>>> IS NO EVIDENCE
    WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE THAT >>>>>>>>>>>>>>>>>> THE CORRECT
    PARTIAL EMULATION OF THE INPUT TO H(P,P) >>>>>>>>>>>>>>>>>> CONCLUSIVELY PROVES THAT
    THE CORRECT AND COMPLETE X86 EMULATION OF THE INPUT >>>>>>>>>>>>>>>>>> TO H(P,P)
    WOULD NEVER STOP RUNNING.

    It is completely obvious that when H(P,P) correctly >>>>>>>>>>>>>>>>>> emulates its
    input that it must emulate the first seven >>>>>>>>>>>>>>>>>> instructions of P.
    Because the seventh instruction of P repeats this >>>>>>>>>>>>>>>>>> process we know
    with complete certainty that the correct and >>>>>>>>>>>>>>>>>> complete emulation of
    P by H would never reach its final “ret” >>>>>>>>>>>>>>>>>> instruction, thus never
    halts.

    If P should have halted (i.e. no infinite loop) then >>>>>>>>>>>>>>>>> your simulation
    detector, S (not H), gets the answer wrong.  You S >>>>>>>>>>>>>>>>> is NOT a halting
    decider.

    /Flibble

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS >>>>>>>>>>>>>>>> NO ACTUAL
    REBUTTAL AT ALL.

    _P()
    [00001352](01)  55              push ebp >>>>>>>>>>>>>>>> [00001353](02)  8bec            mov ebp,esp >>>>>>>>>>>>>>>> [00001355](03)  8b4508          mov eax,[ebp+08] >>>>>>>>>>>>>>>> [00001358](01)  50              push eax      //
    push P [00001359](03)  8b4d08          mov >>>>>>>>>>>>>>>> ecx,[ebp+08] [0000135c](01)  51              push
    ecx      // push P [0000135d](05)  e840feffff >>>>>>>>>>>>>>>> call 000011a2 // call H [00001362](03)  83c408 >>>>>>>>>>>>>>>>    add esp,+08 [00001365](02)  85c0            test
    eax,eax [00001367](02)  7402            jz 0000136b
    [00001369](02)  ebfe            jmp 00001369 >>>>>>>>>>>>>>>> [0000136b](01)  5d              pop ebp >>>>>>>>>>>>>>>> [0000136c](01)  c3              ret >>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]

    It is completely obvious that when H(P,P) correctly >>>>>>>>>>>>>>>> emulates its
    input that it must emulate the first seven
    instructions of P. Because
    the seventh instruction of P repeats this process we >>>>>>>>>>>>>>>> know with
    complete certainty that the correct and complete >>>>>>>>>>>>>>>> emulation of P by H
    would never reach its final “ret” instruction, thus >>>>>>>>>>>>>>>> never halts.

    We are going around and around and around in circles. >>>>>>>>>>>>>>> I will try again:

    If you replace the opcodes "EB FE" at 00001369 with >>>>>>>>>>>>>>> the opcodes "90 90"
    then your H gets the answer wrong: P should have >>>>>>>>>>>>>>> halted.

    /Flibble


    As I already said before this is merely your
    cluelessness that when H(P,P) is invoked the correct >>>>>>>>>>>>>> x86 emulation of the input to H(P,P) makes and code >>>>>>>>>>>>>> after [0000135d] unreachable.

    Wrong, because when that H return the value 0, it will >>>>>>>>>>>>> get there.
    Like I said people that are dumber than a box of rocks >>>>>>>>>>>> won't be able to correctly understand this.

    When H(P,P) is invoked the correctly emulated input to >>>>>>>>>>>> H(P,P) cannot possibly reach any instruction beyond
    [0000135d].

    So, you are defining that you H(P,P) never returns because >>>>>>>>>>> it is caught in the infinite rcursion.

    Thats fine, just says it can't be the correctly answering >>>>>>>>>>> decider you claim it to be.

    I have corrected you on this too many times.


    How. You need to define what H(P,P) actually does.

    I have explained that too many times.

    To understand that H(P,P)==0 is correct we only need to know >>>>>>>> that H performs a correct x86 emulation of its input and then >>>>>>>> examine the execution trace.

    And a CORRECT emulation of the code will Halt if H(P,P)
    returns 0, which it can only do if it does not actually do a
    correct emulation

    The correctly emulated input to H(P,P) never gets past its
    machine address [0000135d].



    Only if H actually doesn't return 0. Yes, H can't correctly
    return 0 if it correctly emulates its input, but you can't drop
    that requirement.

    void P(u32 x)
    {
       if (H(x, x))
         HERE: goto HERE;
       return;
    }

    int main()
    {
       Output("Input_Halts = ", H((u32)P, (u32)P));
    }

    When H returns 0 it does not returns 0 to P it returns 0 to
    main().

    But it also return 0 to the computation P(P), maybe not the copy
    that it is simulating, since it aborts that before it get to it,

    Finally you are not stupid or deceptive.

    If H never returns a value to P then H is not a halting decider; if
    H returns a value of 0 to main() when P halts then H is not a
    halting decider.

    H is not a halting decider; H is a simulation detector, S.

    /Flibble


    In other words you are saying the infintely nested emulation only
    excutes for a few steps and then it stops on its own.

    I am saying that your H is not a halting decider; I am saying that your
    H is just a simulation detector, S.

    /Flibble

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Thu Jun 9 18:17:11 2022
    XPost: comp.theory, sci.logic, sci.math

    On 6/9/22 6:09 PM, olcott wrote:
    On 6/9/2022 4:54 PM, Richard Damon wrote:
    On 6/9/22 5:29 PM, olcott wrote:
    On 6/9/2022 4:13 PM, Richard Damon wrote:

    On 6/9/22 5:00 PM, olcott wrote:
    On 6/9/2022 3:25 PM, Richard Damon wrote:
    On 6/9/22 4:13 PM, olcott wrote:
    On 6/9/2022 2:57 PM, Richard Damon wrote:
    On 6/9/22 3:52 PM, olcott wrote:
    On 6/9/2022 2:38 PM, Richard Damon wrote:

    On 6/9/22 3:26 PM, olcott wrote:
    On 6/9/2022 1:12 PM, Richard Damon wrote:
    On 6/9/22 1:55 PM, olcott wrote:
    On 6/9/2022 12:46 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:39:32 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 12:28 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:15:24 -0500
    olcott <NoOne@NoWhere.com> wrote:
    On 6/9/2022 12:06 PM, Richard Damon wrote:
    On 6/9/22 12:54 PM, olcott wrote:
    On 6/9/2022 11:34 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 6/9/22 11:47 AM, olcott wrote:
    void P(u32 x)
    {
         if (H(x, x))
           HERE: goto HERE;
         return;
    }

    int main()
    {
         P(P);
    }

    _P()
    [000012e7](01)  55              push ebp >>>>>>>>>>>>>>>>>>>>> [000012e8](02)  8bec            mov ebp,esp >>>>>>>>>>>>>>>>>>>>> [000012ea](03)  8b4508          mov eax,[ebp+08]
    [000012ed](01)  50              push eax >>>>>>>>>>>>>>>>>>>>> [000012ee](03)  8b4d08          mov ecx,[ebp+08]
    [000012f1](01)  51              push ecx >>>>>>>>>>>>>>>>>>>>> [000012f2](05)  e880feffff      call 00001177 // >>>>>>>>>>>>>>>>>>>>> call H
    [000012f7](03)  83c408          add esp,+08 >>>>>>>>>>>>>>>>>>>>> [000012fa](02)  85c0            test eax,eax >>>>>>>>>>>>>>>>>>>>> [000012fc](02)  7402            jz 00001300 >>>>>>>>>>>>>>>>>>>>> [000012fe](02)  ebfe            jmp 000012fe >>>>>>>>>>>>>>>>>>>>> [00001300](01)  5d              pop ebp >>>>>>>>>>>>>>>>>>>>> [00001301](01)  c3              ret >>>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [00001301]

    _main()
    [00001307](01)  55              push ebp >>>>>>>>>>>>>>>>>>>>> [00001308](02)  8bec            mov ebp,esp >>>>>>>>>>>>>>>>>>>>> [0000130a](05)  68e7120000      push 000012e7 // >>>>>>>>>>>>>>>>>>>>> push P
    [0000130f](05)  e8d3ffffff      call 000012e7 // >>>>>>>>>>>>>>>>>>>>> call P
    [00001314](03)  83c404          add esp,+04 >>>>>>>>>>>>>>>>>>>>> [00001317](02)  33c0            xor eax,eax >>>>>>>>>>>>>>>>>>>>> [00001319](01)  5d              pop ebp >>>>>>>>>>>>>>>>>>>>> [0000131a](01)  c3              ret >>>>>>>>>>>>>>>>>>>>> Size in bytes:(0020) [0000131a]

        machine   stack     stack     machine    assembly
        address   address   data      code       language
        ========  ========  ========  ========= >>>>>>>>>>>>>>>>>>>>> =============
    [00001307][00102190][00000000] 55         push ebp
    [00001308][00102190][00000000] 8bec       mov ebp,esp
    [0000130a][0010218c][000012e7] 68e7120000 push >>>>>>>>>>>>>>>>>>>>> 000012e7 //
    push P [0000130f][00102188][00001314] e8d3ffffff >>>>>>>>>>>>>>>>>>>>> call 000012e7
    // call P [000012e7][00102184][00102190] 55 push ebp >>>>>>>>>>>>>>>>>>>>>     // enter executed P
    [000012e8][00102184][00102190] 8bec       mov ebp,esp
    [000012ea][00102184][00102190] 8b4508     mov >>>>>>>>>>>>>>>>>>>>> eax,[ebp+08]
    [000012ed][00102180][000012e7] 50         push >>>>>>>>>>>>>>>>>>>>> eax      //
    push P [000012ee][00102180][000012e7] 8b4d08     mov >>>>>>>>>>>>>>>>>>>>> ecx,[ebp+08] [000012f1][0010217c][000012e7] 51 push >>>>>>>>>>>>>>>>>>>>> ecx      // push P [000012f2][00102178][000012f7] >>>>>>>>>>>>>>>>>>>>> e880feffff
    call 00001177 // call H

    Begin Local Halt Decider Simulation   Execution >>>>>>>>>>>>>>>>>>>>> Trace Stored
    at:212244 [000012e7][00212230][00212234] 55 push ebp >>>>>>>>>>>>>>>>>>>>>     // enter emulated P
    [000012e8][00212230][00212234] 8bec        mov ebp,esp
    [000012ea][00212230][00212234] 8b4508      mov >>>>>>>>>>>>>>>>>>>>> eax,[ebp+08]
    [000012ed][0021222c][000012e7] 50          push >>>>>>>>>>>>>>>>>>>>> eax      //
    push P [000012ee][0021222c][000012e7] 8b4d08      mov
    ecx,[ebp+08] [000012f1][00212228][000012e7] 51 push >>>>>>>>>>>>>>>>>>>>> ecx      // push P [000012f2][00212224][000012f7] >>>>>>>>>>>>>>>>>>>>> e880feffff
    call 00001177 // call H

    So, by what instruction reference manual is a call >>>>>>>>>>>>>>>>>>>> 00001177
    followedby the execution of the instruction at >>>>>>>>>>>>>>>>>>>> 000012e7.

    Your "CPU" is broken, or emulation incorrect. >>>>>>>>>>>>>>>>>>>>
    FAIL.
    [000012e7][0025cc58][0025cc5c] 55          push >>>>>>>>>>>>>>>>>>>>> ebp      //
    enter emulated P
    [000012e8][0025cc58][0025cc5c] 8bec        mov ebp,esp
    [000012ea][0025cc58][0025cc5c] 8b4508      mov >>>>>>>>>>>>>>>>>>>>> eax,[ebp+08]
    [000012ed][0025cc54][000012e7] 50          push >>>>>>>>>>>>>>>>>>>>> eax      //
    push P [000012ee][0025cc54][000012e7] 8b4d08      mov
    ecx,[ebp+08] [000012f1][0025cc50][000012e7] 51 push >>>>>>>>>>>>>>>>>>>>> ecx      // push P [000012f2][0025cc4c][000012f7] >>>>>>>>>>>>>>>>>>>>> e880feffff
    call 00001177 // call H Local Halt Decider: >>>>>>>>>>>>>>>>>>>>> Infinite Recursion
    Detected Simulation Stopped

    It is completely obvious that when H(P,P) correctly >>>>>>>>>>>>>>>>>>>>> emulates
    its input that it must emulate the first seven >>>>>>>>>>>>>>>>>>>>> instructions of
    P. Because the seventh instruction of P repeats >>>>>>>>>>>>>>>>>>>>> this process we
    know with complete certainty that the correct and >>>>>>>>>>>>>>>>>>>>> complete
    emulation of P by H would never reach its final “ret” >>>>>>>>>>>>>>>>>>>>> instruction, thus never halts.

    Problem, the 7th intruction DOESN't "Just repeat the >>>>>>>>>>>>>>>>>>>> procedure",
    because that H always has the option to abort its >>>>>>>>>>>>>>>>>>>> simulation,
    just like this onne did, and return to its P and see >>>>>>>>>>>>>>>>>>>> it halt.
    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS >>>>>>>>>>>>>>>>>>> NO ACTUAL
    REBUTTAL AT ALL:

    The partial correct x86 emulation of the input to H(P,P) >>>>>>>>>>>>>>>>>>> conclusively proves that the complete and correct x86 >>>>>>>>>>>>>>>>>>> emulation
    would never stop running.


    You SAY that, but you don't answer the actual >>>>>>>>>>>>>>>>>> questions about HOW.

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO >>>>>>>>>>>>>>>>> EVIDENCE
    WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE THAT THE >>>>>>>>>>>>>>>>> CORRECT
    PARTIAL EMULATION OF THE INPUT TO H(P,P) CONCLUSIVELY >>>>>>>>>>>>>>>>> PROVES THAT
    THE CORRECT AND COMPLETE X86 EMULATION OF THE INPUT TO >>>>>>>>>>>>>>>>> H(P,P)
    WOULD NEVER STOP RUNNING.

    It is completely obvious that when H(P,P) correctly >>>>>>>>>>>>>>>>> emulates its
    input that it must emulate the first seven instructions >>>>>>>>>>>>>>>>> of P.
    Because the seventh instruction of P repeats this >>>>>>>>>>>>>>>>> process we know
    with complete certainty that the correct and complete >>>>>>>>>>>>>>>>> emulation of
    P by H would never reach its final “ret” instruction, >>>>>>>>>>>>>>>>> thus never
    halts.

    If P should have halted (i.e. no infinite loop) then >>>>>>>>>>>>>>>> your simulation
    detector, S (not H), gets the answer wrong.  You S is >>>>>>>>>>>>>>>> NOT a halting
    decider.

    /Flibble

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO >>>>>>>>>>>>>>> ACTUAL
    REBUTTAL AT ALL.

    _P()
    [00001352](01)  55              push ebp >>>>>>>>>>>>>>> [00001353](02)  8bec            mov ebp,esp >>>>>>>>>>>>>>> [00001355](03)  8b4508          mov eax,[ebp+08] >>>>>>>>>>>>>>> [00001358](01)  50              push eax      // push P
    [00001359](03)  8b4d08          mov ecx,[ebp+08] >>>>>>>>>>>>>>> [0000135c](01)  51              push ecx      // push P
    [0000135d](05)  e840feffff      call 000011a2 // call H >>>>>>>>>>>>>>> [00001362](03)  83c408          add esp,+08 >>>>>>>>>>>>>>> [00001365](02)  85c0            test eax,eax >>>>>>>>>>>>>>> [00001367](02)  7402            jz 0000136b >>>>>>>>>>>>>>> [00001369](02)  ebfe            jmp 00001369 >>>>>>>>>>>>>>> [0000136b](01)  5d              pop ebp >>>>>>>>>>>>>>> [0000136c](01)  c3              ret >>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]

    It is completely obvious that when H(P,P) correctly >>>>>>>>>>>>>>> emulates its
    input that it must emulate the first seven instructions >>>>>>>>>>>>>>> of P. Because
    the seventh instruction of P repeats this process we know >>>>>>>>>>>>>>> with
    complete certainty that the correct and complete >>>>>>>>>>>>>>> emulation of P by H
    would never reach its final “ret” instruction, thus never >>>>>>>>>>>>>>> halts.

    We are going around and around and around in circles. I >>>>>>>>>>>>>> will try again:

    If you replace the opcodes "EB FE" at 00001369 with the >>>>>>>>>>>>>> opcodes "90 90"
    then your H gets the answer wrong: P should have halted. >>>>>>>>>>>>>>
    /Flibble


    As I already said before this is merely your cluelessness >>>>>>>>>>>>> that when H(P,P) is invoked the correct x86 emulation of >>>>>>>>>>>>> the input to H(P,P) makes and code after [0000135d]
    unreachable.

    Wrong, because when that H return the value 0, it will get >>>>>>>>>>>> there.
    Like I said people that are dumber than a box of rocks won't >>>>>>>>>>> be able to correctly understand this.

    When H(P,P) is invoked the correctly emulated input to H(P,P) >>>>>>>>>>> cannot possibly reach any instruction beyond [0000135d].

    So, you are defining that you H(P,P) never returns because it >>>>>>>>>> is caught in the infinite rcursion.

    Thats fine, just says it can't be the correctly answering
    decider you claim it to be.

    I have corrected you on this too many times.


    How. You need to define what H(P,P) actually does.

    I have explained that too many times.

    To understand that H(P,P)==0 is correct we only need to know that >>>>>>> H performs a correct x86 emulation of its input and then examine >>>>>>> the execution trace.

    And a CORRECT emulation of the code will Halt if H(P,P) returns 0, >>>>>> which it can only do if it does not actually do a correct emulation >>>>>>

    The correctly emulated input to H(P,P) never gets past its machine
    address [0000135d].



    Only if H actually doesn't return 0. Yes, H can't correctly return 0
    if it correctly emulates its input, but you can't drop that
    requirement.

    void P(u32 x)
    {
       if (H(x, x))
         HERE: goto HERE;
       return;
    }

    int main()
    {
       Output("Input_Halts = ", H((u32)P, (u32)P));
    }

    When H returns 0 it does not returns 0 to P it returns 0 to main().

    But it also return 0 to the computation P(P), maybe not the copy that
    it is simulating, since it aborts that before it get to it,

    Finally you are not stupid or deceptive.




    So, you agree that your H(P,P) that returns a 0, claiming it to be
    correct, also returns that 0 to P(P) and thus P(P) Halts, and thus
    H(P,P) is INCORRECT in saying that its input represents a non-halting computation?

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Mr Flibble on Thu Jun 9 17:18:38 2022
    XPost: comp.theory, sci.logic, sci.math

    On 6/9/2022 5:15 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:09:08 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 4:54 PM, Richard Damon wrote:
    On 6/9/22 5:29 PM, olcott wrote:
    On 6/9/2022 4:13 PM, Richard Damon wrote:

    On 6/9/22 5:00 PM, olcott wrote:
    On 6/9/2022 3:25 PM, Richard Damon wrote:
    On 6/9/22 4:13 PM, olcott wrote:
    On 6/9/2022 2:57 PM, Richard Damon wrote:
    On 6/9/22 3:52 PM, olcott wrote:
    On 6/9/2022 2:38 PM, Richard Damon wrote:

    On 6/9/22 3:26 PM, olcott wrote:
    On 6/9/2022 1:12 PM, Richard Damon wrote:
    On 6/9/22 1:55 PM, olcott wrote:
    On 6/9/2022 12:46 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:39:32 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 12:28 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:15:24 -0500
    olcott <NoOne@NoWhere.com> wrote:
    On 6/9/2022 12:06 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 6/9/22 12:54 PM, olcott wrote:
    On 6/9/2022 11:34 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 6/9/22 11:47 AM, olcott wrote:
    void P(u32 x)
    {
         if (H(x, x))
           HERE: goto HERE;
         return;
    }

    int main()
    {
         P(P);
    }

    _P()
    [000012e7](01)  55              push ebp >>>>>>>>>>>>>>>>>>>>>> [000012e8](02)  8bec            mov ebp,esp >>>>>>>>>>>>>>>>>>>>>> [000012ea](03)  8b4508          mov eax,[ebp+08]
    [000012ed](01)  50              push eax >>>>>>>>>>>>>>>>>>>>>> [000012ee](03)  8b4d08          mov ecx,[ebp+08]
    [000012f1](01)  51              push ecx >>>>>>>>>>>>>>>>>>>>>> [000012f2](05)  e880feffff      call 00001177 // >>>>>>>>>>>>>>>>>>>>>> call H [000012f7](03)  83c408          add >>>>>>>>>>>>>>>>>>>>>> esp,+08 [000012fa](02)  85c0            test >>>>>>>>>>>>>>>>>>>>>> eax,eax [000012fc](02)  7402            jz >>>>>>>>>>>>>>>>>>>>>> 00001300 [000012fe](02)  ebfe            jmp >>>>>>>>>>>>>>>>>>>>>> 000012fe [00001300](01)  5d              pop ebp
    [00001301](01)  c3              ret >>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [00001301]

    _main()
    [00001307](01)  55              push ebp >>>>>>>>>>>>>>>>>>>>>> [00001308](02)  8bec            mov ebp,esp >>>>>>>>>>>>>>>>>>>>>> [0000130a](05)  68e7120000      push 000012e7 // >>>>>>>>>>>>>>>>>>>>>> push P [0000130f](05)  e8d3ffffff      call >>>>>>>>>>>>>>>>>>>>>> 000012e7 // call P [00001314](03)  83c404 >>>>>>>>>>>>>>>>>>>>>>   add esp,+04 [00001317](02)  33c0 >>>>>>>>>>>>>>>>>>>>>> xor eax,eax [00001319](01)  5d              pop
    ebp [0000131a](01)  c3              ret >>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0020) [0000131a]

        machine   stack     stack     machine >>>>>>>>>>>>>>>>>>>>>> assembly address   address   data      code >>>>>>>>>>>>>>>>>>>>>> language ========  ========  ======== >>>>>>>>>>>>>>>>>>>>>> ========= =============
    [00001307][00102190][00000000] 55         push >>>>>>>>>>>>>>>>>>>>>> ebp [00001308][00102190][00000000] 8bec >>>>>>>>>>>>>>>>>>>>>> mov ebp,esp [0000130a][0010218c][000012e7] >>>>>>>>>>>>>>>>>>>>>> 68e7120000 push 000012e7 //
    push P [0000130f][00102188][00001314] e8d3ffffff >>>>>>>>>>>>>>>>>>>>>> call 000012e7
    // call P [000012e7][00102184][00102190] 55 push >>>>>>>>>>>>>>>>>>>>>> ebp // enter executed P
    [000012e8][00102184][00102190] 8bec       mov >>>>>>>>>>>>>>>>>>>>>> ebp,esp [000012ea][00102184][00102190] 8b4508 >>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08]
    [000012ed][00102180][000012e7] 50         push >>>>>>>>>>>>>>>>>>>>>> eax      //
    push P [000012ee][00102180][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08] [000012f1][0010217c][000012e7] >>>>>>>>>>>>>>>>>>>>>> 51 push ecx      // push P
    [000012f2][00102178][000012f7] e880feffff >>>>>>>>>>>>>>>>>>>>>> call 00001177 // call H

    Begin Local Halt Decider Simulation   Execution >>>>>>>>>>>>>>>>>>>>>> Trace Stored
    at:212244 [000012e7][00212230][00212234] 55 push >>>>>>>>>>>>>>>>>>>>>> ebp // enter emulated P
    [000012e8][00212230][00212234] 8bec        mov >>>>>>>>>>>>>>>>>>>>>> ebp,esp [000012ea][00212230][00212234] 8b4508 >>>>>>>>>>>>>>>>>>>>>>   mov eax,[ebp+08]
    [000012ed][0021222c][000012e7] 50          push >>>>>>>>>>>>>>>>>>>>>> eax      //
    push P [000012ee][0021222c][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08] [000012f1][00212228][000012e7] >>>>>>>>>>>>>>>>>>>>>> 51 push ecx      // push P
    [000012f2][00212224][000012f7] e880feffff >>>>>>>>>>>>>>>>>>>>>> call 00001177 // call H

    So, by what instruction reference manual is a >>>>>>>>>>>>>>>>>>>>> call 00001177
    followedby the execution of the instruction at >>>>>>>>>>>>>>>>>>>>> 000012e7.

    Your "CPU" is broken, or emulation incorrect. >>>>>>>>>>>>>>>>>>>>>
    FAIL.
    [000012e7][0025cc58][0025cc5c] 55          push >>>>>>>>>>>>>>>>>>>>>> ebp      //
    enter emulated P
    [000012e8][0025cc58][0025cc5c] 8bec        mov >>>>>>>>>>>>>>>>>>>>>> ebp,esp [000012ea][0025cc58][0025cc5c] 8b4508 >>>>>>>>>>>>>>>>>>>>>>   mov eax,[ebp+08]
    [000012ed][0025cc54][000012e7] 50          push >>>>>>>>>>>>>>>>>>>>>> eax      //
    push P [000012ee][0025cc54][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08] [000012f1][0025cc50][000012e7] >>>>>>>>>>>>>>>>>>>>>> 51 push ecx      // push P
    [000012f2][0025cc4c][000012f7] e880feffff >>>>>>>>>>>>>>>>>>>>>> call 00001177 // call H Local Halt Decider: >>>>>>>>>>>>>>>>>>>>>> Infinite Recursion
    Detected Simulation Stopped

    It is completely obvious that when H(P,P) >>>>>>>>>>>>>>>>>>>>>> correctly emulates
    its input that it must emulate the first seven >>>>>>>>>>>>>>>>>>>>>> instructions of
    P. Because the seventh instruction of P repeats >>>>>>>>>>>>>>>>>>>>>> this process we
    know with complete certainty that the correct >>>>>>>>>>>>>>>>>>>>>> and complete
    emulation of P by H would never reach its final >>>>>>>>>>>>>>>>>>>>>> “ret” instruction, thus never halts. >>>>>>>>>>>>>>>>>>>>>
    Problem, the 7th intruction DOESN't "Just repeat >>>>>>>>>>>>>>>>>>>>> the procedure",
    because that H always has the option to abort its >>>>>>>>>>>>>>>>>>>>> simulation,
    just like this onne did, and return to its P and >>>>>>>>>>>>>>>>>>>>> see it halt.
    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS >>>>>>>>>>>>>>>>>>>> IS NO ACTUAL
    REBUTTAL AT ALL:

    The partial correct x86 emulation of the input to >>>>>>>>>>>>>>>>>>>> H(P,P) conclusively proves that the complete and >>>>>>>>>>>>>>>>>>>> correct x86 emulation
    would never stop running.


    You SAY that, but you don't answer the actual >>>>>>>>>>>>>>>>>>> questions about HOW.

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS >>>>>>>>>>>>>>>>>> NO EVIDENCE
    WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE THAT >>>>>>>>>>>>>>>>>> THE CORRECT
    PARTIAL EMULATION OF THE INPUT TO H(P,P)
    CONCLUSIVELY PROVES THAT
    THE CORRECT AND COMPLETE X86 EMULATION OF THE INPUT >>>>>>>>>>>>>>>>>> TO H(P,P)
    WOULD NEVER STOP RUNNING.

    It is completely obvious that when H(P,P) correctly >>>>>>>>>>>>>>>>>> emulates its
    input that it must emulate the first seven >>>>>>>>>>>>>>>>>> instructions of P.
    Because the seventh instruction of P repeats this >>>>>>>>>>>>>>>>>> process we know
    with complete certainty that the correct and >>>>>>>>>>>>>>>>>> complete emulation of
    P by H would never reach its final “ret” >>>>>>>>>>>>>>>>>> instruction, thus never
    halts.

    If P should have halted (i.e. no infinite loop) then >>>>>>>>>>>>>>>>> your simulation
    detector, S (not H), gets the answer wrong.  You S is >>>>>>>>>>>>>>>>> NOT a halting
    decider.

    /Flibble

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS >>>>>>>>>>>>>>>> NO ACTUAL
    REBUTTAL AT ALL.

    _P()
    [00001352](01)  55              push ebp >>>>>>>>>>>>>>>> [00001353](02)  8bec            mov ebp,esp >>>>>>>>>>>>>>>> [00001355](03)  8b4508          mov eax,[ebp+08] >>>>>>>>>>>>>>>> [00001358](01)  50              push eax      // push P
    [00001359](03)  8b4d08          mov ecx,[ebp+08] >>>>>>>>>>>>>>>> [0000135c](01)  51              push ecx      // push P
    [0000135d](05)  e840feffff      call 000011a2 // call H >>>>>>>>>>>>>>>> [00001362](03)  83c408          add esp,+08 >>>>>>>>>>>>>>>> [00001365](02)  85c0            test eax,eax >>>>>>>>>>>>>>>> [00001367](02)  7402            jz 0000136b >>>>>>>>>>>>>>>> [00001369](02)  ebfe            jmp 00001369 >>>>>>>>>>>>>>>> [0000136b](01)  5d              pop ebp >>>>>>>>>>>>>>>> [0000136c](01)  c3              ret >>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]

    It is completely obvious that when H(P,P) correctly >>>>>>>>>>>>>>>> emulates its
    input that it must emulate the first seven
    instructions of P. Because
    the seventh instruction of P repeats this process we >>>>>>>>>>>>>>>> know with
    complete certainty that the correct and complete >>>>>>>>>>>>>>>> emulation of P by H
    would never reach its final “ret” instruction, thus >>>>>>>>>>>>>>>> never halts.

    We are going around and around and around in circles. I >>>>>>>>>>>>>>> will try again:

    If you replace the opcodes "EB FE" at 00001369 with the >>>>>>>>>>>>>>> opcodes "90 90"
    then your H gets the answer wrong: P should have halted. >>>>>>>>>>>>>>>
    /Flibble


    As I already said before this is merely your
    cluelessness that when H(P,P) is invoked the correct x86 >>>>>>>>>>>>>> emulation of the input to H(P,P) makes and code after >>>>>>>>>>>>>> [0000135d] unreachable.

    Wrong, because when that H return the value 0, it will >>>>>>>>>>>>> get there.
    Like I said people that are dumber than a box of rocks >>>>>>>>>>>> won't be able to correctly understand this.

    When H(P,P) is invoked the correctly emulated input to >>>>>>>>>>>> H(P,P) cannot possibly reach any instruction beyond
    [0000135d].

    So, you are defining that you H(P,P) never returns because >>>>>>>>>>> it is caught in the infinite rcursion.

    Thats fine, just says it can't be the correctly answering >>>>>>>>>>> decider you claim it to be.

    I have corrected you on this too many times.


    How. You need to define what H(P,P) actually does.

    I have explained that too many times.

    To understand that H(P,P)==0 is correct we only need to know
    that H performs a correct x86 emulation of its input and then
    examine the execution trace.

    And a CORRECT emulation of the code will Halt if H(P,P) returns
    0, which it can only do if it does not actually do a correct
    emulation

    The correctly emulated input to H(P,P) never gets past its
    machine address [0000135d].



    Only if H actually doesn't return 0. Yes, H can't correctly
    return 0 if it correctly emulates its input, but you can't drop
    that requirement.

    void P(u32 x)
    {
       if (H(x, x))
         HERE: goto HERE;
       return;
    }

    int main()
    {
       Output("Input_Halts = ", H((u32)P, (u32)P));
    }

    When H returns 0 it does not returns 0 to P it returns 0 to
    main().

    But it also return 0 to the computation P(P), maybe not the copy
    that it is simulating, since it aborts that before it get to it,

    Finally you are not stupid or deceptive.

    If H never returns a value to P then H is not a halting decider; if H
    returns a value of 0 to main() when P halts then H is not a halting
    decider.

    H is not a halting decider; H is a simulation detector, S.

    /Flibble


    In other words you are saying the infintely nested emulation only
    excutes for a few steps and then it stops on its own.

    --
    Copyright 2022 Pete Olcott

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

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Thu Jun 9 18:33:41 2022
    XPost: comp.theory, sci.logic, sci.math

    On 6/9/22 6:18 PM, olcott wrote:
    On 6/9/2022 5:15 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:09:08 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 4:54 PM, Richard Damon wrote:
    On 6/9/22 5:29 PM, olcott wrote:
    On 6/9/2022 4:13 PM, Richard Damon wrote:

    On 6/9/22 5:00 PM, olcott wrote:
    On 6/9/2022 3:25 PM, Richard Damon wrote:
    On 6/9/22 4:13 PM, olcott wrote:
    On 6/9/2022 2:57 PM, Richard Damon wrote:
    On 6/9/22 3:52 PM, olcott wrote:
    On 6/9/2022 2:38 PM, Richard Damon wrote:

    On 6/9/22 3:26 PM, olcott wrote:
    On 6/9/2022 1:12 PM, Richard Damon wrote:
    On 6/9/22 1:55 PM, olcott wrote:
    On 6/9/2022 12:46 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:39:32 -0500
    olcott <NoOne@NoWhere.com> wrote:
    On 6/9/2022 12:28 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:15:24 -0500
    olcott <NoOne@NoWhere.com> wrote:
    On 6/9/2022 12:06 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 6/9/22 12:54 PM, olcott wrote:
    On 6/9/2022 11:34 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 6/9/22 11:47 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> void P(u32 x)
    {
          if (H(x, x))
            HERE: goto HERE;
          return;
    }

    int main()
    {
          P(P);
    }

    _P()
    [000012e7](01)  55              push ebp >>>>>>>>>>>>>>>>>>>>>>> [000012e8](02)  8bec            mov ebp,esp >>>>>>>>>>>>>>>>>>>>>>> [000012ea](03)  8b4508          mov eax,[ebp+08]
    [000012ed](01)  50              push eax >>>>>>>>>>>>>>>>>>>>>>> [000012ee](03)  8b4d08          mov ecx,[ebp+08]
    [000012f1](01)  51              push ecx >>>>>>>>>>>>>>>>>>>>>>> [000012f2](05)  e880feffff      call 00001177 // >>>>>>>>>>>>>>>>>>>>>>> call H [000012f7](03)  83c408          add >>>>>>>>>>>>>>>>>>>>>>> esp,+08 [000012fa](02)  85c0            test
    eax,eax [000012fc](02)  7402            jz >>>>>>>>>>>>>>>>>>>>>>> 00001300 [000012fe](02)  ebfe            jmp
    000012fe [00001300](01)  5d              pop ebp
    [00001301](01)  c3              ret >>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [00001301]

    _main()
    [00001307](01)  55              push ebp >>>>>>>>>>>>>>>>>>>>>>> [00001308](02)  8bec            mov ebp,esp >>>>>>>>>>>>>>>>>>>>>>> [0000130a](05)  68e7120000      push 000012e7 // >>>>>>>>>>>>>>>>>>>>>>> push P [0000130f](05)  e8d3ffffff      call >>>>>>>>>>>>>>>>>>>>>>> 000012e7 // call P [00001314](03)  83c404 >>>>>>>>>>>>>>>>>>>>>>>    add esp,+04 [00001317](02)  33c0 >>>>>>>>>>>>>>>>>>>>>>> xor eax,eax [00001319](01)  5d              pop
    ebp [0000131a](01)  c3              ret >>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0020) [0000131a]

         machine   stack     stack     machine
    assembly address   address   data      code >>>>>>>>>>>>>>>>>>>>>>>   language ========  ========  ======== >>>>>>>>>>>>>>>>>>>>>>> ========= =============
    [00001307][00102190][00000000] 55         push >>>>>>>>>>>>>>>>>>>>>>> ebp [00001308][00102190][00000000] 8bec >>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp [0000130a][0010218c][000012e7] >>>>>>>>>>>>>>>>>>>>>>> 68e7120000 push 000012e7 //
    push P [0000130f][00102188][00001314] e8d3ffffff >>>>>>>>>>>>>>>>>>>>>>> call 000012e7
    // call P [000012e7][00102184][00102190] 55 push >>>>>>>>>>>>>>>>>>>>>>> ebp // enter executed P
    [000012e8][00102184][00102190] 8bec       mov >>>>>>>>>>>>>>>>>>>>>>> ebp,esp [000012ea][00102184][00102190] 8b4508 >>>>>>>>>>>>>>>>>>>>>>>   mov eax,[ebp+08]
    [000012ed][00102180][000012e7] 50         push >>>>>>>>>>>>>>>>>>>>>>> eax      //
    push P [000012ee][00102180][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08] [000012f1][0010217c][000012e7] >>>>>>>>>>>>>>>>>>>>>>> 51 push ecx      // push P
    [000012f2][00102178][000012f7] e880feffff >>>>>>>>>>>>>>>>>>>>>>> call 00001177 // call H

    Begin Local Halt Decider Simulation   Execution >>>>>>>>>>>>>>>>>>>>>>> Trace Stored
    at:212244 [000012e7][00212230][00212234] 55 push >>>>>>>>>>>>>>>>>>>>>>> ebp // enter emulated P
    [000012e8][00212230][00212234] 8bec        mov >>>>>>>>>>>>>>>>>>>>>>> ebp,esp [000012ea][00212230][00212234] 8b4508 >>>>>>>>>>>>>>>>>>>>>>>    mov eax,[ebp+08]
    [000012ed][0021222c][000012e7] 50          push
    eax      //
    push P [000012ee][0021222c][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>   mov ecx,[ebp+08] [000012f1][00212228][000012e7] >>>>>>>>>>>>>>>>>>>>>>> 51 push ecx      // push P
    [000012f2][00212224][000012f7] e880feffff >>>>>>>>>>>>>>>>>>>>>>> call 00001177 // call H

    So, by what instruction reference manual is a >>>>>>>>>>>>>>>>>>>>>> call 00001177
    followedby the execution of the instruction at >>>>>>>>>>>>>>>>>>>>>> 000012e7.

    Your "CPU" is broken, or emulation incorrect. >>>>>>>>>>>>>>>>>>>>>>
    FAIL.
    [000012e7][0025cc58][0025cc5c] 55          push
    ebp      //
    enter emulated P
    [000012e8][0025cc58][0025cc5c] 8bec        mov >>>>>>>>>>>>>>>>>>>>>>> ebp,esp [000012ea][0025cc58][0025cc5c] 8b4508 >>>>>>>>>>>>>>>>>>>>>>>    mov eax,[ebp+08]
    [000012ed][0025cc54][000012e7] 50          push
    eax      //
    push P [000012ee][0025cc54][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>   mov ecx,[ebp+08] [000012f1][0025cc50][000012e7] >>>>>>>>>>>>>>>>>>>>>>> 51 push ecx      // push P
    [000012f2][0025cc4c][000012f7] e880feffff >>>>>>>>>>>>>>>>>>>>>>> call 00001177 // call H Local Halt Decider: >>>>>>>>>>>>>>>>>>>>>>> Infinite Recursion
    Detected Simulation Stopped

    It is completely obvious that when H(P,P) >>>>>>>>>>>>>>>>>>>>>>> correctly emulates
    its input that it must emulate the first seven >>>>>>>>>>>>>>>>>>>>>>> instructions of
    P. Because the seventh instruction of P repeats >>>>>>>>>>>>>>>>>>>>>>> this process we
    know with complete certainty that the correct >>>>>>>>>>>>>>>>>>>>>>> and complete
    emulation of P by H would never reach its final >>>>>>>>>>>>>>>>>>>>>>> “ret” instruction, thus never halts. >>>>>>>>>>>>>>>>>>>>>>
    Problem, the 7th intruction DOESN't "Just repeat >>>>>>>>>>>>>>>>>>>>>> the procedure",
    because that H always has the option to abort its >>>>>>>>>>>>>>>>>>>>>> simulation,
    just like this onne did, and return to its P and >>>>>>>>>>>>>>>>>>>>>> see it halt.
    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS >>>>>>>>>>>>>>>>>>>>> IS NO ACTUAL
    REBUTTAL AT ALL:

    The partial correct x86 emulation of the input to >>>>>>>>>>>>>>>>>>>>> H(P,P) conclusively proves that the complete and >>>>>>>>>>>>>>>>>>>>> correct x86 emulation
    would never stop running.

    You SAY that, but you don't answer the actual >>>>>>>>>>>>>>>>>>>> questions about HOW.

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS >>>>>>>>>>>>>>>>>>> NO EVIDENCE
    WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE THAT >>>>>>>>>>>>>>>>>>> THE CORRECT
    PARTIAL EMULATION OF THE INPUT TO H(P,P) >>>>>>>>>>>>>>>>>>> CONCLUSIVELY PROVES THAT
    THE CORRECT AND COMPLETE X86 EMULATION OF THE INPUT >>>>>>>>>>>>>>>>>>> TO H(P,P)
    WOULD NEVER STOP RUNNING.

    It is completely obvious that when H(P,P) correctly >>>>>>>>>>>>>>>>>>> emulates its
    input that it must emulate the first seven >>>>>>>>>>>>>>>>>>> instructions of P.
    Because the seventh instruction of P repeats this >>>>>>>>>>>>>>>>>>> process we know
    with complete certainty that the correct and >>>>>>>>>>>>>>>>>>> complete emulation of
    P by H would never reach its final “ret” >>>>>>>>>>>>>>>>>>> instruction, thus never
    halts.

    If P should have halted (i.e. no infinite loop) then >>>>>>>>>>>>>>>>>> your simulation
    detector, S (not H), gets the answer wrong.  You S is >>>>>>>>>>>>>>>>>> NOT a halting
    decider.

    /Flibble

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS >>>>>>>>>>>>>>>>> NO ACTUAL
    REBUTTAL AT ALL.

    _P()
    [00001352](01)  55              push ebp >>>>>>>>>>>>>>>>> [00001353](02)  8bec            mov ebp,esp >>>>>>>>>>>>>>>>> [00001355](03)  8b4508          mov eax,[ebp+08] >>>>>>>>>>>>>>>>> [00001358](01)  50              push eax      // push P
    [00001359](03)  8b4d08          mov ecx,[ebp+08] >>>>>>>>>>>>>>>>> [0000135c](01)  51              push ecx      // push P
    [0000135d](05)  e840feffff      call 000011a2 // call H >>>>>>>>>>>>>>>>> [00001362](03)  83c408          add esp,+08 >>>>>>>>>>>>>>>>> [00001365](02)  85c0            test eax,eax >>>>>>>>>>>>>>>>> [00001367](02)  7402            jz 0000136b >>>>>>>>>>>>>>>>> [00001369](02)  ebfe            jmp 00001369 >>>>>>>>>>>>>>>>> [0000136b](01)  5d              pop ebp >>>>>>>>>>>>>>>>> [0000136c](01)  c3              ret >>>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]

    It is completely obvious that when H(P,P) correctly >>>>>>>>>>>>>>>>> emulates its
    input that it must emulate the first seven
    instructions of P. Because
    the seventh instruction of P repeats this process we >>>>>>>>>>>>>>>>> know with
    complete certainty that the correct and complete >>>>>>>>>>>>>>>>> emulation of P by H
    would never reach its final “ret” instruction, thus >>>>>>>>>>>>>>>>> never halts.

    We are going around and around and around in circles. I >>>>>>>>>>>>>>>> will try again:

    If you replace the opcodes "EB FE" at 00001369 with the >>>>>>>>>>>>>>>> opcodes "90 90"
    then your H gets the answer wrong: P should have halted. >>>>>>>>>>>>>>>>
    /Flibble

    As I already said before this is merely your
    cluelessness that when H(P,P) is invoked the correct x86 >>>>>>>>>>>>>>> emulation of the input to H(P,P) makes and code after >>>>>>>>>>>>>>> [0000135d] unreachable.

    Wrong, because when that H return the value 0, it will >>>>>>>>>>>>>> get there.
    Like I said people that are dumber than a box of rocks >>>>>>>>>>>>> won't be able to correctly understand this.

    When H(P,P) is invoked the correctly emulated input to >>>>>>>>>>>>> H(P,P) cannot possibly reach any instruction beyond
    [0000135d].

    So, you are defining that you H(P,P) never returns because >>>>>>>>>>>> it is caught in the infinite rcursion.

    Thats fine, just says it can't be the correctly answering >>>>>>>>>>>> decider you claim it to be.

    I have corrected you on this too many times.

    How. You need to define what H(P,P) actually does.

    I have explained that too many times.

    To understand that H(P,P)==0 is correct we only need to know >>>>>>>>> that H performs a correct x86 emulation of its input and then >>>>>>>>> examine the execution trace.

    And a CORRECT emulation of the code will Halt if H(P,P) returns >>>>>>>> 0, which it can only do if it does not actually do a correct
    emulation

    The correctly emulated input to H(P,P) never gets past its
    machine address [0000135d].


    Only if H actually doesn't return 0. Yes, H can't correctly
    return 0 if it correctly emulates its input, but you can't drop
    that requirement.

    void P(u32 x)
    {
        if (H(x, x))
          HERE: goto HERE;
        return;
    }

    int main()
    {
        Output("Input_Halts = ", H((u32)P, (u32)P));
    }

    When H returns 0 it does not returns 0 to P it returns 0 to
    main().

    But it also return 0 to the computation P(P), maybe not the copy
    that it is simulating, since it aborts that before it get to it,

    Finally you are not stupid or deceptive.

    If H never returns a value to P then H is not a halting decider; if H
    returns a value of 0 to main() when P halts then H is not a halting
    decider.

    H is not a halting decider; H is a simulation detector, S.

    /Flibble


    In other words you are saying the infintely nested emulation only
    excutes for a few steps and then it stops on its own.


    No, the "infinitely nested emulation" halts when the first H(P,P) that
    P(P) called aborts it simulation.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Richard Damon on Thu Jun 9 17:34:01 2022
    XPost: comp.theory, sci.logic, sci.math

    On 6/9/2022 5:17 PM, Richard Damon wrote:
    On 6/9/22 6:09 PM, olcott wrote:
    On 6/9/2022 4:54 PM, Richard Damon wrote:
    On 6/9/22 5:29 PM, olcott wrote:
    On 6/9/2022 4:13 PM, Richard Damon wrote:

    On 6/9/22 5:00 PM, olcott wrote:
    On 6/9/2022 3:25 PM, Richard Damon wrote:
    On 6/9/22 4:13 PM, olcott wrote:
    On 6/9/2022 2:57 PM, Richard Damon wrote:
    On 6/9/22 3:52 PM, olcott wrote:
    On 6/9/2022 2:38 PM, Richard Damon wrote:

    On 6/9/22 3:26 PM, olcott wrote:
    On 6/9/2022 1:12 PM, Richard Damon wrote:
    On 6/9/22 1:55 PM, olcott wrote:
    On 6/9/2022 12:46 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:39:32 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 12:28 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:15:24 -0500
    olcott <NoOne@NoWhere.com> wrote:
    On 6/9/2022 12:06 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 6/9/22 12:54 PM, olcott wrote:
    On 6/9/2022 11:34 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 6/9/22 11:47 AM, olcott wrote:
    void P(u32 x)
    {
         if (H(x, x))
           HERE: goto HERE;
         return;
    }

    int main()
    {
         P(P);
    }

    _P()
    [000012e7](01)  55              push ebp >>>>>>>>>>>>>>>>>>>>>> [000012e8](02)  8bec            mov ebp,esp >>>>>>>>>>>>>>>>>>>>>> [000012ea](03)  8b4508          mov eax,[ebp+08]
    [000012ed](01)  50              push eax >>>>>>>>>>>>>>>>>>>>>> [000012ee](03)  8b4d08          mov ecx,[ebp+08]
    [000012f1](01)  51              push ecx >>>>>>>>>>>>>>>>>>>>>> [000012f2](05)  e880feffff      call 00001177 // >>>>>>>>>>>>>>>>>>>>>> call H
    [000012f7](03)  83c408          add esp,+08 >>>>>>>>>>>>>>>>>>>>>> [000012fa](02)  85c0            test eax,eax >>>>>>>>>>>>>>>>>>>>>> [000012fc](02)  7402            jz 00001300 >>>>>>>>>>>>>>>>>>>>>> [000012fe](02)  ebfe            jmp 000012fe >>>>>>>>>>>>>>>>>>>>>> [00001300](01)  5d              pop ebp >>>>>>>>>>>>>>>>>>>>>> [00001301](01)  c3              ret >>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [00001301]

    _main()
    [00001307](01)  55              push ebp >>>>>>>>>>>>>>>>>>>>>> [00001308](02)  8bec            mov ebp,esp >>>>>>>>>>>>>>>>>>>>>> [0000130a](05)  68e7120000      push 000012e7 // >>>>>>>>>>>>>>>>>>>>>> push P
    [0000130f](05)  e8d3ffffff      call 000012e7 // >>>>>>>>>>>>>>>>>>>>>> call P
    [00001314](03)  83c404          add esp,+04 >>>>>>>>>>>>>>>>>>>>>> [00001317](02)  33c0            xor eax,eax >>>>>>>>>>>>>>>>>>>>>> [00001319](01)  5d              pop ebp >>>>>>>>>>>>>>>>>>>>>> [0000131a](01)  c3              ret >>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0020) [0000131a]

        machine   stack     stack     machine    assembly
        address   address   data      code       language
        ========  ========  ========  ========= >>>>>>>>>>>>>>>>>>>>>> =============
    [00001307][00102190][00000000] 55         push ebp
    [00001308][00102190][00000000] 8bec       mov ebp,esp
    [0000130a][0010218c][000012e7] 68e7120000 push >>>>>>>>>>>>>>>>>>>>>> 000012e7 //
    push P [0000130f][00102188][00001314] e8d3ffffff >>>>>>>>>>>>>>>>>>>>>> call 000012e7
    // call P [000012e7][00102184][00102190] 55 push ebp >>>>>>>>>>>>>>>>>>>>>>     // enter executed P
    [000012e8][00102184][00102190] 8bec       mov ebp,esp
    [000012ea][00102184][00102190] 8b4508     mov >>>>>>>>>>>>>>>>>>>>>> eax,[ebp+08]
    [000012ed][00102180][000012e7] 50         push >>>>>>>>>>>>>>>>>>>>>> eax      //
    push P [000012ee][00102180][000012e7] 8b4d08     mov >>>>>>>>>>>>>>>>>>>>>> ecx,[ebp+08] [000012f1][0010217c][000012e7] 51 push >>>>>>>>>>>>>>>>>>>>>> ecx      // push P [000012f2][00102178][000012f7] >>>>>>>>>>>>>>>>>>>>>> e880feffff
    call 00001177 // call H

    Begin Local Halt Decider Simulation   Execution >>>>>>>>>>>>>>>>>>>>>> Trace Stored
    at:212244 [000012e7][00212230][00212234] 55 push ebp >>>>>>>>>>>>>>>>>>>>>>     // enter emulated P
    [000012e8][00212230][00212234] 8bec        mov >>>>>>>>>>>>>>>>>>>>>> ebp,esp
    [000012ea][00212230][00212234] 8b4508      mov >>>>>>>>>>>>>>>>>>>>>> eax,[ebp+08]
    [000012ed][0021222c][000012e7] 50          push >>>>>>>>>>>>>>>>>>>>>> eax      //
    push P [000012ee][0021222c][000012e7] 8b4d08      mov
    ecx,[ebp+08] [000012f1][00212228][000012e7] 51 push >>>>>>>>>>>>>>>>>>>>>> ecx      // push P [000012f2][00212224][000012f7] >>>>>>>>>>>>>>>>>>>>>> e880feffff
    call 00001177 // call H

    So, by what instruction reference manual is a call >>>>>>>>>>>>>>>>>>>>> 00001177
    followedby the execution of the instruction at >>>>>>>>>>>>>>>>>>>>> 000012e7.

    Your "CPU" is broken, or emulation incorrect. >>>>>>>>>>>>>>>>>>>>>
    FAIL.
    [000012e7][0025cc58][0025cc5c] 55          push >>>>>>>>>>>>>>>>>>>>>> ebp      //
    enter emulated P
    [000012e8][0025cc58][0025cc5c] 8bec        mov >>>>>>>>>>>>>>>>>>>>>> ebp,esp
    [000012ea][0025cc58][0025cc5c] 8b4508      mov >>>>>>>>>>>>>>>>>>>>>> eax,[ebp+08]
    [000012ed][0025cc54][000012e7] 50          push >>>>>>>>>>>>>>>>>>>>>> eax      //
    push P [000012ee][0025cc54][000012e7] 8b4d08      mov
    ecx,[ebp+08] [000012f1][0025cc50][000012e7] 51 push >>>>>>>>>>>>>>>>>>>>>> ecx      // push P [000012f2][0025cc4c][000012f7] >>>>>>>>>>>>>>>>>>>>>> e880feffff
    call 00001177 // call H Local Halt Decider: >>>>>>>>>>>>>>>>>>>>>> Infinite Recursion
    Detected Simulation Stopped

    It is completely obvious that when H(P,P) >>>>>>>>>>>>>>>>>>>>>> correctly emulates
    its input that it must emulate the first seven >>>>>>>>>>>>>>>>>>>>>> instructions of
    P. Because the seventh instruction of P repeats >>>>>>>>>>>>>>>>>>>>>> this process we
    know with complete certainty that the correct and >>>>>>>>>>>>>>>>>>>>>> complete
    emulation of P by H would never reach its final “ret”
    instruction, thus never halts.

    Problem, the 7th intruction DOESN't "Just repeat >>>>>>>>>>>>>>>>>>>>> the procedure",
    because that H always has the option to abort its >>>>>>>>>>>>>>>>>>>>> simulation,
    just like this onne did, and return to its P and >>>>>>>>>>>>>>>>>>>>> see it halt.
    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS >>>>>>>>>>>>>>>>>>>> NO ACTUAL
    REBUTTAL AT ALL:

    The partial correct x86 emulation of the input to >>>>>>>>>>>>>>>>>>>> H(P,P)
    conclusively proves that the complete and correct >>>>>>>>>>>>>>>>>>>> x86 emulation
    would never stop running.


    You SAY that, but you don't answer the actual >>>>>>>>>>>>>>>>>>> questions about HOW.

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS >>>>>>>>>>>>>>>>>> NO EVIDENCE
    WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE THAT THE >>>>>>>>>>>>>>>>>> CORRECT
    PARTIAL EMULATION OF THE INPUT TO H(P,P) CONCLUSIVELY >>>>>>>>>>>>>>>>>> PROVES THAT
    THE CORRECT AND COMPLETE X86 EMULATION OF THE INPUT TO >>>>>>>>>>>>>>>>>> H(P,P)
    WOULD NEVER STOP RUNNING.

    It is completely obvious that when H(P,P) correctly >>>>>>>>>>>>>>>>>> emulates its
    input that it must emulate the first seven >>>>>>>>>>>>>>>>>> instructions of P.
    Because the seventh instruction of P repeats this >>>>>>>>>>>>>>>>>> process we know
    with complete certainty that the correct and complete >>>>>>>>>>>>>>>>>> emulation of
    P by H would never reach its final “ret” instruction, >>>>>>>>>>>>>>>>>> thus never
    halts.

    If P should have halted (i.e. no infinite loop) then >>>>>>>>>>>>>>>>> your simulation
    detector, S (not H), gets the answer wrong.  You S is >>>>>>>>>>>>>>>>> NOT a halting
    decider.

    /Flibble

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO >>>>>>>>>>>>>>>> ACTUAL
    REBUTTAL AT ALL.

    _P()
    [00001352](01)  55              push ebp >>>>>>>>>>>>>>>> [00001353](02)  8bec            mov ebp,esp >>>>>>>>>>>>>>>> [00001355](03)  8b4508          mov eax,[ebp+08] >>>>>>>>>>>>>>>> [00001358](01)  50              push eax      // push P
    [00001359](03)  8b4d08          mov ecx,[ebp+08] >>>>>>>>>>>>>>>> [0000135c](01)  51              push ecx      // push P
    [0000135d](05)  e840feffff      call 000011a2 // call H >>>>>>>>>>>>>>>> [00001362](03)  83c408          add esp,+08 >>>>>>>>>>>>>>>> [00001365](02)  85c0            test eax,eax >>>>>>>>>>>>>>>> [00001367](02)  7402            jz 0000136b >>>>>>>>>>>>>>>> [00001369](02)  ebfe            jmp 00001369 >>>>>>>>>>>>>>>> [0000136b](01)  5d              pop ebp >>>>>>>>>>>>>>>> [0000136c](01)  c3              ret >>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]

    It is completely obvious that when H(P,P) correctly >>>>>>>>>>>>>>>> emulates its
    input that it must emulate the first seven instructions >>>>>>>>>>>>>>>> of P. Because
    the seventh instruction of P repeats this process we >>>>>>>>>>>>>>>> know with
    complete certainty that the correct and complete >>>>>>>>>>>>>>>> emulation of P by H
    would never reach its final “ret” instruction, thus >>>>>>>>>>>>>>>> never halts.

    We are going around and around and around in circles. I >>>>>>>>>>>>>>> will try again:

    If you replace the opcodes "EB FE" at 00001369 with the >>>>>>>>>>>>>>> opcodes "90 90"
    then your H gets the answer wrong: P should have halted. >>>>>>>>>>>>>>>
    /Flibble


    As I already said before this is merely your cluelessness >>>>>>>>>>>>>> that when H(P,P) is invoked the correct x86 emulation of >>>>>>>>>>>>>> the input to H(P,P) makes and code after [0000135d] >>>>>>>>>>>>>> unreachable.

    Wrong, because when that H return the value 0, it will get >>>>>>>>>>>>> there.
    Like I said people that are dumber than a box of rocks won't >>>>>>>>>>>> be able to correctly understand this.

    When H(P,P) is invoked the correctly emulated input to >>>>>>>>>>>> H(P,P) cannot possibly reach any instruction beyond [0000135d]. >>>>>>>>>>>
    So, you are defining that you H(P,P) never returns because it >>>>>>>>>>> is caught in the infinite rcursion.

    Thats fine, just says it can't be the correctly answering >>>>>>>>>>> decider you claim it to be.

    I have corrected you on this too many times.


    How. You need to define what H(P,P) actually does.

    I have explained that too many times.

    To understand that H(P,P)==0 is correct we only need to know
    that H performs a correct x86 emulation of its input and then
    examine the execution trace.

    And a CORRECT emulation of the code will Halt if H(P,P) returns
    0, which it can only do if it does not actually do a correct
    emulation


    The correctly emulated input to H(P,P) never gets past its machine >>>>>> address [0000135d].



    Only if H actually doesn't return 0. Yes, H can't correctly return
    0 if it correctly emulates its input, but you can't drop that
    requirement.

    void P(u32 x)
    {
       if (H(x, x))
         HERE: goto HERE;
       return;
    }

    int main()
    {
       Output("Input_Halts = ", H((u32)P, (u32)P));
    }

    When H returns 0 it does not returns 0 to P it returns 0 to main().

    But it also return 0 to the computation P(P), maybe not the copy that
    it is simulating, since it aborts that before it get to it,

    Finally you are not stupid or deceptive.




    So, you agree that your H(P,P) that returns a 0, claiming it to be
    correct, also returns that 0 to P(P) and thus P(P) Halts, and thus
    H(P,P) is INCORRECT in saying that its input represents a non-halting computation?

    That you are waaaay too stupid to understand that I correctly proved
    that P(P) and the correct simulatuon of the input to H(P,P) actually
    have different halting behavior is no actual rebuttal at all.


    --
    Copyright 2022 Pete Olcott

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

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Mr Flibble on Thu Jun 9 17:35:05 2022
    XPost: comp.theory, sci.logic, sci.math

    On 6/9/2022 5:27 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:18:38 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 5:15 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:09:08 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 4:54 PM, Richard Damon wrote:
    On 6/9/22 5:29 PM, olcott wrote:
    On 6/9/2022 4:13 PM, Richard Damon wrote:

    On 6/9/22 5:00 PM, olcott wrote:
    On 6/9/2022 3:25 PM, Richard Damon wrote:
    On 6/9/22 4:13 PM, olcott wrote:
    On 6/9/2022 2:57 PM, Richard Damon wrote:
    On 6/9/22 3:52 PM, olcott wrote:
    On 6/9/2022 2:38 PM, Richard Damon wrote:

    On 6/9/22 3:26 PM, olcott wrote:
    On 6/9/2022 1:12 PM, Richard Damon wrote:
    On 6/9/22 1:55 PM, olcott wrote:
    On 6/9/2022 12:46 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:39:32 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 12:28 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:15:24 -0500
    olcott <NoOne@NoWhere.com> wrote:
    On 6/9/2022 12:06 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 6/9/22 12:54 PM, olcott wrote:
    On 6/9/2022 11:34 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 11:47 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> void P(u32 x)
    {
         if (H(x, x))
           HERE: goto HERE; >>>>>>>>>>>>>>>>>>>>>>>>      return;
    }

    int main()
    {
         P(P);
    }

    _P()
    [000012e7](01)  55              push ebp >>>>>>>>>>>>>>>>>>>>>>>> [000012e8](02)  8bec            mov ebp,esp
    [000012ea](03)  8b4508          mov >>>>>>>>>>>>>>>>>>>>>>>> eax,[ebp+08] [000012ed](01)  50 >>>>>>>>>>>>>>>>>>>>>>>> push eax [000012ee](03)  8b4d08          mov >>>>>>>>>>>>>>>>>>>>>>>> ecx,[ebp+08] [000012f1](01)  51 >>>>>>>>>>>>>>>>>>>>>>>> push ecx [000012f2](05)  e880feffff      call >>>>>>>>>>>>>>>>>>>>>>>> 00001177 // call H [000012f7](03)  83c408 >>>>>>>>>>>>>>>>>>>>>>>>     add esp,+08 [000012fa](02)  85c0 >>>>>>>>>>>>>>>>>>>>>>>> test eax,eax [000012fc](02)  7402 >>>>>>>>>>>>>>>>>>>>>>>> jz 00001300 [000012fe](02)  ebfe            jmp
    000012fe [00001300](01)  5d              pop
    ebp [00001301](01)  c3              ret >>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [00001301] >>>>>>>>>>>>>>>>>>>>>>>>
    _main()
    [00001307](01)  55              push ebp >>>>>>>>>>>>>>>>>>>>>>>> [00001308](02)  8bec            mov ebp,esp
    [0000130a](05)  68e7120000      push 000012e7 >>>>>>>>>>>>>>>>>>>>>>>> // push P [0000130f](05)  e8d3ffffff      call >>>>>>>>>>>>>>>>>>>>>>>> 000012e7 // call P [00001314](03)  83c404 >>>>>>>>>>>>>>>>>>>>>>>>   add esp,+04 [00001317](02)  33c0 >>>>>>>>>>>>>>>>>>>>>>>> xor eax,eax [00001319](01)  5d              pop
    ebp [0000131a](01)  c3              ret >>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0020) [0000131a] >>>>>>>>>>>>>>>>>>>>>>>>
        machine   stack     stack     machine
    assembly address   address   data      code >>>>>>>>>>>>>>>>>>>>>>>> language ========  ========  ======== >>>>>>>>>>>>>>>>>>>>>>>> ========= =============
    [00001307][00102190][00000000] 55         push >>>>>>>>>>>>>>>>>>>>>>>> ebp [00001308][00102190][00000000] 8bec >>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp [0000130a][0010218c][000012e7] >>>>>>>>>>>>>>>>>>>>>>>> 68e7120000 push 000012e7 //
    push P [0000130f][00102188][00001314] >>>>>>>>>>>>>>>>>>>>>>>> e8d3ffffff call 000012e7
    // call P [000012e7][00102184][00102190] 55 >>>>>>>>>>>>>>>>>>>>>>>> push ebp // enter executed P
    [000012e8][00102184][00102190] 8bec       mov >>>>>>>>>>>>>>>>>>>>>>>> ebp,esp [000012ea][00102184][00102190] 8b4508 >>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08]
    [000012ed][00102180][000012e7] 50         push >>>>>>>>>>>>>>>>>>>>>>>> eax      //
    push P [000012ee][00102180][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08] [000012f1][0010217c][000012e7] >>>>>>>>>>>>>>>>>>>>>>>> 51 push ecx      // push P >>>>>>>>>>>>>>>>>>>>>>>> [000012f2][00102178][000012f7] e880feffff >>>>>>>>>>>>>>>>>>>>>>>> call 00001177 // call H

    Begin Local Halt Decider Simulation   Execution >>>>>>>>>>>>>>>>>>>>>>>> Trace Stored
    at:212244 [000012e7][00212230][00212234] 55 >>>>>>>>>>>>>>>>>>>>>>>> push ebp // enter emulated P
    [000012e8][00212230][00212234] 8bec        mov >>>>>>>>>>>>>>>>>>>>>>>> ebp,esp [000012ea][00212230][00212234] 8b4508 >>>>>>>>>>>>>>>>>>>>>>>>   mov eax,[ebp+08]
    [000012ed][0021222c][000012e7] 50          push
    eax      //
    push P [000012ee][0021222c][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08]
    [000012f1][00212228][000012e7] 51 push ecx >>>>>>>>>>>>>>>>>>>>>>>> // push P [000012f2][00212224][000012f7] >>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H >>>>>>>>>>>>>>>>>>>>>>>
    So, by what instruction reference manual is a >>>>>>>>>>>>>>>>>>>>>>> call 00001177
    followedby the execution of the instruction at >>>>>>>>>>>>>>>>>>>>>>> 000012e7.

    Your "CPU" is broken, or emulation incorrect. >>>>>>>>>>>>>>>>>>>>>>>
    FAIL.
    [000012e7][0025cc58][0025cc5c] 55          push
    ebp      //
    enter emulated P
    [000012e8][0025cc58][0025cc5c] 8bec        mov >>>>>>>>>>>>>>>>>>>>>>>> ebp,esp [000012ea][0025cc58][0025cc5c] 8b4508 >>>>>>>>>>>>>>>>>>>>>>>>   mov eax,[ebp+08]
    [000012ed][0025cc54][000012e7] 50          push
    eax      //
    push P [000012ee][0025cc54][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08]
    [000012f1][0025cc50][000012e7] 51 push ecx >>>>>>>>>>>>>>>>>>>>>>>> // push P [000012f2][0025cc4c][000012f7] >>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H Local Halt >>>>>>>>>>>>>>>>>>>>>>>> Decider: Infinite Recursion
    Detected Simulation Stopped

    It is completely obvious that when H(P,P) >>>>>>>>>>>>>>>>>>>>>>>> correctly emulates
    its input that it must emulate the first seven >>>>>>>>>>>>>>>>>>>>>>>> instructions of
    P. Because the seventh instruction of P repeats >>>>>>>>>>>>>>>>>>>>>>>> this process we
    know with complete certainty that the correct >>>>>>>>>>>>>>>>>>>>>>>> and complete
    emulation of P by H would never reach its final >>>>>>>>>>>>>>>>>>>>>>>> “ret” instruction, thus never halts. >>>>>>>>>>>>>>>>>>>>>>>
    Problem, the 7th intruction DOESN't "Just repeat >>>>>>>>>>>>>>>>>>>>>>> the procedure",
    because that H always has the option to abort >>>>>>>>>>>>>>>>>>>>>>> its simulation,
    just like this onne did, and return to its P and >>>>>>>>>>>>>>>>>>>>>>> see it halt.
    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS >>>>>>>>>>>>>>>>>>>>>> IS NO ACTUAL
    REBUTTAL AT ALL:

    The partial correct x86 emulation of the input to >>>>>>>>>>>>>>>>>>>>>> H(P,P) conclusively proves that the complete and >>>>>>>>>>>>>>>>>>>>>> correct x86 emulation
    would never stop running.


    You SAY that, but you don't answer the actual >>>>>>>>>>>>>>>>>>>>> questions about HOW.

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS >>>>>>>>>>>>>>>>>>>> IS NO EVIDENCE
    WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE THAT >>>>>>>>>>>>>>>>>>>> THE CORRECT
    PARTIAL EMULATION OF THE INPUT TO H(P,P) >>>>>>>>>>>>>>>>>>>> CONCLUSIVELY PROVES THAT
    THE CORRECT AND COMPLETE X86 EMULATION OF THE INPUT >>>>>>>>>>>>>>>>>>>> TO H(P,P)
    WOULD NEVER STOP RUNNING.

    It is completely obvious that when H(P,P) correctly >>>>>>>>>>>>>>>>>>>> emulates its
    input that it must emulate the first seven >>>>>>>>>>>>>>>>>>>> instructions of P.
    Because the seventh instruction of P repeats this >>>>>>>>>>>>>>>>>>>> process we know
    with complete certainty that the correct and >>>>>>>>>>>>>>>>>>>> complete emulation of
    P by H would never reach its final “ret” >>>>>>>>>>>>>>>>>>>> instruction, thus never
    halts.

    If P should have halted (i.e. no infinite loop) then >>>>>>>>>>>>>>>>>>> your simulation
    detector, S (not H), gets the answer wrong.  You S >>>>>>>>>>>>>>>>>>> is NOT a halting
    decider.

    /Flibble

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS >>>>>>>>>>>>>>>>>> NO ACTUAL
    REBUTTAL AT ALL.

    _P()
    [00001352](01)  55              push ebp >>>>>>>>>>>>>>>>>> [00001353](02)  8bec            mov ebp,esp >>>>>>>>>>>>>>>>>> [00001355](03)  8b4508          mov eax,[ebp+08] >>>>>>>>>>>>>>>>>> [00001358](01)  50              push eax      //
    push P [00001359](03)  8b4d08          mov >>>>>>>>>>>>>>>>>> ecx,[ebp+08] [0000135c](01)  51              push
    ecx      // push P [0000135d](05)  e840feffff >>>>>>>>>>>>>>>>>> call 000011a2 // call H [00001362](03)  83c408 >>>>>>>>>>>>>>>>>>    add esp,+08 [00001365](02)  85c0            test
    eax,eax [00001367](02)  7402            jz 0000136b
    [00001369](02)  ebfe            jmp 00001369 >>>>>>>>>>>>>>>>>> [0000136b](01)  5d              pop ebp >>>>>>>>>>>>>>>>>> [0000136c](01)  c3              ret >>>>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]

    It is completely obvious that when H(P,P) correctly >>>>>>>>>>>>>>>>>> emulates its
    input that it must emulate the first seven >>>>>>>>>>>>>>>>>> instructions of P. Because
    the seventh instruction of P repeats this process we >>>>>>>>>>>>>>>>>> know with
    complete certainty that the correct and complete >>>>>>>>>>>>>>>>>> emulation of P by H
    would never reach its final “ret” instruction, thus >>>>>>>>>>>>>>>>>> never halts.

    We are going around and around and around in circles. >>>>>>>>>>>>>>>>> I will try again:

    If you replace the opcodes "EB FE" at 00001369 with >>>>>>>>>>>>>>>>> the opcodes "90 90"
    then your H gets the answer wrong: P should have >>>>>>>>>>>>>>>>> halted.

    /Flibble


    As I already said before this is merely your
    cluelessness that when H(P,P) is invoked the correct >>>>>>>>>>>>>>>> x86 emulation of the input to H(P,P) makes and code >>>>>>>>>>>>>>>> after [0000135d] unreachable.

    Wrong, because when that H return the value 0, it will >>>>>>>>>>>>>>> get there.
    Like I said people that are dumber than a box of rocks >>>>>>>>>>>>>> won't be able to correctly understand this.

    When H(P,P) is invoked the correctly emulated input to >>>>>>>>>>>>>> H(P,P) cannot possibly reach any instruction beyond >>>>>>>>>>>>>> [0000135d].

    So, you are defining that you H(P,P) never returns because >>>>>>>>>>>>> it is caught in the infinite rcursion.

    Thats fine, just says it can't be the correctly answering >>>>>>>>>>>>> decider you claim it to be.

    I have corrected you on this too many times.


    How. You need to define what H(P,P) actually does.

    I have explained that too many times.

    To understand that H(P,P)==0 is correct we only need to know >>>>>>>>>> that H performs a correct x86 emulation of its input and then >>>>>>>>>> examine the execution trace.

    And a CORRECT emulation of the code will Halt if H(P,P)
    returns 0, which it can only do if it does not actually do a >>>>>>>>> correct emulation

    The correctly emulated input to H(P,P) never gets past its
    machine address [0000135d].



    Only if H actually doesn't return 0. Yes, H can't correctly
    return 0 if it correctly emulates its input, but you can't drop
    that requirement.

    void P(u32 x)
    {
       if (H(x, x))
         HERE: goto HERE;
       return;
    }

    int main()
    {
       Output("Input_Halts = ", H((u32)P, (u32)P));
    }

    When H returns 0 it does not returns 0 to P it returns 0 to
    main().

    But it also return 0 to the computation P(P), maybe not the copy
    that it is simulating, since it aborts that before it get to it,

    Finally you are not stupid or deceptive.

    If H never returns a value to P then H is not a halting decider; if
    H returns a value of 0 to main() when P halts then H is not a
    halting decider.

    H is not a halting decider; H is a simulation detector, S.

    /Flibble


    In other words you are saying the infintely nested emulation only
    excutes for a few steps and then it stops on its own.

    I am saying that your H is not a halting decider; I am saying that your
    H is just a simulation detector, S.

    /Flibble


    You are saying that you simply "don't believe in" simulating halt deciders.

    --
    Copyright 2022 Pete Olcott

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

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Richard Damon on Thu Jun 9 17:37:51 2022
    XPost: comp.theory, sci.logic, sci.math

    On 6/9/2022 5:33 PM, Richard Damon wrote:
    On 6/9/22 6:18 PM, olcott wrote:
    On 6/9/2022 5:15 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:09:08 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 4:54 PM, Richard Damon wrote:
    On 6/9/22 5:29 PM, olcott wrote:
    On 6/9/2022 4:13 PM, Richard Damon wrote:

    On 6/9/22 5:00 PM, olcott wrote:
    On 6/9/2022 3:25 PM, Richard Damon wrote:
    On 6/9/22 4:13 PM, olcott wrote:
    On 6/9/2022 2:57 PM, Richard Damon wrote:
    On 6/9/22 3:52 PM, olcott wrote:
    On 6/9/2022 2:38 PM, Richard Damon wrote:

    On 6/9/22 3:26 PM, olcott wrote:
    On 6/9/2022 1:12 PM, Richard Damon wrote:
    On 6/9/22 1:55 PM, olcott wrote:
    On 6/9/2022 12:46 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:39:32 -0500
    olcott <NoOne@NoWhere.com> wrote:
    On 6/9/2022 12:28 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:15:24 -0500
    olcott <NoOne@NoWhere.com> wrote:
    On 6/9/2022 12:06 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 6/9/22 12:54 PM, olcott wrote:
    On 6/9/2022 11:34 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 11:47 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> void P(u32 x)
    {
          if (H(x, x))
            HERE: goto HERE; >>>>>>>>>>>>>>>>>>>>>>>>       return;
    }

    int main()
    {
          P(P);
    }

    _P()
    [000012e7](01)  55              push ebp >>>>>>>>>>>>>>>>>>>>>>>> [000012e8](02)  8bec            mov ebp,esp
    [000012ea](03)  8b4508          mov eax,[ebp+08]
    [000012ed](01)  50              push eax >>>>>>>>>>>>>>>>>>>>>>>> [000012ee](03)  8b4d08          mov ecx,[ebp+08]
    [000012f1](01)  51              push ecx >>>>>>>>>>>>>>>>>>>>>>>> [000012f2](05)  e880feffff      call 00001177 // >>>>>>>>>>>>>>>>>>>>>>>> call H [000012f7](03)  83c408          add >>>>>>>>>>>>>>>>>>>>>>>> esp,+08 [000012fa](02)  85c0            test
    eax,eax [000012fc](02)  7402            jz >>>>>>>>>>>>>>>>>>>>>>>> 00001300 [000012fe](02)  ebfe            jmp
    000012fe [00001300](01)  5d              pop ebp
    [00001301](01)  c3              ret >>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [00001301] >>>>>>>>>>>>>>>>>>>>>>>>
    _main()
    [00001307](01)  55              push ebp >>>>>>>>>>>>>>>>>>>>>>>> [00001308](02)  8bec            mov ebp,esp
    [0000130a](05)  68e7120000      push 000012e7 // >>>>>>>>>>>>>>>>>>>>>>>> push P [0000130f](05)  e8d3ffffff      call >>>>>>>>>>>>>>>>>>>>>>>> 000012e7 // call P [00001314](03)  83c404 >>>>>>>>>>>>>>>>>>>>>>>>    add esp,+04 [00001317](02)  33c0 >>>>>>>>>>>>>>>>>>>>>>>> xor eax,eax [00001319](01)  5d              pop
    ebp [0000131a](01)  c3              ret >>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0020) [0000131a] >>>>>>>>>>>>>>>>>>>>>>>>
         machine   stack     stack     machine
    assembly address   address   data      code >>>>>>>>>>>>>>>>>>>>>>>>   language ========  ========  ======== >>>>>>>>>>>>>>>>>>>>>>>> ========= =============
    [00001307][00102190][00000000] 55         push >>>>>>>>>>>>>>>>>>>>>>>> ebp [00001308][00102190][00000000] 8bec >>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp [0000130a][0010218c][000012e7] >>>>>>>>>>>>>>>>>>>>>>>> 68e7120000 push 000012e7 //
    push P [0000130f][00102188][00001314] e8d3ffffff >>>>>>>>>>>>>>>>>>>>>>>> call 000012e7
    // call P [000012e7][00102184][00102190] 55 push >>>>>>>>>>>>>>>>>>>>>>>> ebp // enter executed P
    [000012e8][00102184][00102190] 8bec       mov >>>>>>>>>>>>>>>>>>>>>>>> ebp,esp [000012ea][00102184][00102190] 8b4508 >>>>>>>>>>>>>>>>>>>>>>>>   mov eax,[ebp+08]
    [000012ed][00102180][000012e7] 50         push >>>>>>>>>>>>>>>>>>>>>>>> eax      //
    push P [000012ee][00102180][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08] [000012f1][0010217c][000012e7] >>>>>>>>>>>>>>>>>>>>>>>> 51 push ecx      // push P >>>>>>>>>>>>>>>>>>>>>>>> [000012f2][00102178][000012f7] e880feffff >>>>>>>>>>>>>>>>>>>>>>>> call 00001177 // call H

    Begin Local Halt Decider Simulation   Execution >>>>>>>>>>>>>>>>>>>>>>>> Trace Stored
    at:212244 [000012e7][00212230][00212234] 55 push >>>>>>>>>>>>>>>>>>>>>>>> ebp // enter emulated P
    [000012e8][00212230][00212234] 8bec        mov >>>>>>>>>>>>>>>>>>>>>>>> ebp,esp [000012ea][00212230][00212234] 8b4508 >>>>>>>>>>>>>>>>>>>>>>>>    mov eax,[ebp+08]
    [000012ed][0021222c][000012e7] 50          push
    eax      //
    push P [000012ee][0021222c][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>   mov ecx,[ebp+08] [000012f1][00212228][000012e7] >>>>>>>>>>>>>>>>>>>>>>>> 51 push ecx      // push P >>>>>>>>>>>>>>>>>>>>>>>> [000012f2][00212224][000012f7] e880feffff >>>>>>>>>>>>>>>>>>>>>>>> call 00001177 // call H

    So, by what instruction reference manual is a >>>>>>>>>>>>>>>>>>>>>>> call 00001177
    followedby the execution of the instruction at >>>>>>>>>>>>>>>>>>>>>>> 000012e7.

    Your "CPU" is broken, or emulation incorrect. >>>>>>>>>>>>>>>>>>>>>>>
    FAIL.
    [000012e7][0025cc58][0025cc5c] 55          push
    ebp      //
    enter emulated P
    [000012e8][0025cc58][0025cc5c] 8bec        mov >>>>>>>>>>>>>>>>>>>>>>>> ebp,esp [000012ea][0025cc58][0025cc5c] 8b4508 >>>>>>>>>>>>>>>>>>>>>>>>    mov eax,[ebp+08]
    [000012ed][0025cc54][000012e7] 50          push
    eax      //
    push P [000012ee][0025cc54][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>   mov ecx,[ebp+08] [000012f1][0025cc50][000012e7] >>>>>>>>>>>>>>>>>>>>>>>> 51 push ecx      // push P >>>>>>>>>>>>>>>>>>>>>>>> [000012f2][0025cc4c][000012f7] e880feffff >>>>>>>>>>>>>>>>>>>>>>>> call 00001177 // call H Local Halt Decider: >>>>>>>>>>>>>>>>>>>>>>>> Infinite Recursion
    Detected Simulation Stopped

    It is completely obvious that when H(P,P) >>>>>>>>>>>>>>>>>>>>>>>> correctly emulates
    its input that it must emulate the first seven >>>>>>>>>>>>>>>>>>>>>>>> instructions of
    P. Because the seventh instruction of P repeats >>>>>>>>>>>>>>>>>>>>>>>> this process we
    know with complete certainty that the correct >>>>>>>>>>>>>>>>>>>>>>>> and complete
    emulation of P by H would never reach its final >>>>>>>>>>>>>>>>>>>>>>>> “ret” instruction, thus never halts. >>>>>>>>>>>>>>>>>>>>>>>
    Problem, the 7th intruction DOESN't "Just repeat >>>>>>>>>>>>>>>>>>>>>>> the procedure",
    because that H always has the option to abort its >>>>>>>>>>>>>>>>>>>>>>> simulation,
    just like this onne did, and return to its P and >>>>>>>>>>>>>>>>>>>>>>> see it halt.
    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS >>>>>>>>>>>>>>>>>>>>>> IS NO ACTUAL
    REBUTTAL AT ALL:

    The partial correct x86 emulation of the input to >>>>>>>>>>>>>>>>>>>>>> H(P,P) conclusively proves that the complete and >>>>>>>>>>>>>>>>>>>>>> correct x86 emulation
    would never stop running.

    You SAY that, but you don't answer the actual >>>>>>>>>>>>>>>>>>>>> questions about HOW.

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS >>>>>>>>>>>>>>>>>>>> NO EVIDENCE
    WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE THAT >>>>>>>>>>>>>>>>>>>> THE CORRECT
    PARTIAL EMULATION OF THE INPUT TO H(P,P) >>>>>>>>>>>>>>>>>>>> CONCLUSIVELY PROVES THAT
    THE CORRECT AND COMPLETE X86 EMULATION OF THE INPUT >>>>>>>>>>>>>>>>>>>> TO H(P,P)
    WOULD NEVER STOP RUNNING.

    It is completely obvious that when H(P,P) correctly >>>>>>>>>>>>>>>>>>>> emulates its
    input that it must emulate the first seven >>>>>>>>>>>>>>>>>>>> instructions of P.
    Because the seventh instruction of P repeats this >>>>>>>>>>>>>>>>>>>> process we know
    with complete certainty that the correct and >>>>>>>>>>>>>>>>>>>> complete emulation of
    P by H would never reach its final “ret” >>>>>>>>>>>>>>>>>>>> instruction, thus never
    halts.

    If P should have halted (i.e. no infinite loop) then >>>>>>>>>>>>>>>>>>> your simulation
    detector, S (not H), gets the answer wrong.  You S is >>>>>>>>>>>>>>>>>>> NOT a halting
    decider.

    /Flibble

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS >>>>>>>>>>>>>>>>>> NO ACTUAL
    REBUTTAL AT ALL.

    _P()
    [00001352](01)  55              push ebp >>>>>>>>>>>>>>>>>> [00001353](02)  8bec            mov ebp,esp >>>>>>>>>>>>>>>>>> [00001355](03)  8b4508          mov eax,[ebp+08] >>>>>>>>>>>>>>>>>> [00001358](01)  50              push eax      // push P
    [00001359](03)  8b4d08          mov ecx,[ebp+08] >>>>>>>>>>>>>>>>>> [0000135c](01)  51              push ecx      // push P
    [0000135d](05)  e840feffff      call 000011a2 // call H
    [00001362](03)  83c408          add esp,+08 >>>>>>>>>>>>>>>>>> [00001365](02)  85c0            test eax,eax >>>>>>>>>>>>>>>>>> [00001367](02)  7402            jz 0000136b >>>>>>>>>>>>>>>>>> [00001369](02)  ebfe            jmp 00001369 >>>>>>>>>>>>>>>>>> [0000136b](01)  5d              pop ebp >>>>>>>>>>>>>>>>>> [0000136c](01)  c3              ret >>>>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]

    It is completely obvious that when H(P,P) correctly >>>>>>>>>>>>>>>>>> emulates its
    input that it must emulate the first seven >>>>>>>>>>>>>>>>>> instructions of P. Because
    the seventh instruction of P repeats this process we >>>>>>>>>>>>>>>>>> know with
    complete certainty that the correct and complete >>>>>>>>>>>>>>>>>> emulation of P by H
    would never reach its final “ret” instruction, thus >>>>>>>>>>>>>>>>>> never halts.

    We are going around and around and around in circles. I >>>>>>>>>>>>>>>>> will try again:

    If you replace the opcodes "EB FE" at 00001369 with the >>>>>>>>>>>>>>>>> opcodes "90 90"
    then your H gets the answer wrong: P should have halted. >>>>>>>>>>>>>>>>>
    /Flibble

    As I already said before this is merely your
    cluelessness that when H(P,P) is invoked the correct x86 >>>>>>>>>>>>>>>> emulation of the input to H(P,P) makes and code after >>>>>>>>>>>>>>>> [0000135d] unreachable.

    Wrong, because when that H return the value 0, it will >>>>>>>>>>>>>>> get there.
    Like I said people that are dumber than a box of rocks >>>>>>>>>>>>>> won't be able to correctly understand this.

    When H(P,P) is invoked the correctly emulated input to >>>>>>>>>>>>>> H(P,P) cannot possibly reach any instruction beyond >>>>>>>>>>>>>> [0000135d].

    So, you are defining that you H(P,P) never returns because >>>>>>>>>>>>> it is caught in the infinite rcursion.

    Thats fine, just says it can't be the correctly answering >>>>>>>>>>>>> decider you claim it to be.

    I have corrected you on this too many times.

    How. You need to define what H(P,P) actually does.

    I have explained that too many times.

    To understand that H(P,P)==0 is correct we only need to know >>>>>>>>>> that H performs a correct x86 emulation of its input and then >>>>>>>>>> examine the execution trace.

    And a CORRECT emulation of the code will Halt if H(P,P) returns >>>>>>>>> 0, which it can only do if it does not actually do a correct >>>>>>>>> emulation

    The correctly emulated input to H(P,P) never gets past its
    machine address [0000135d].


    Only if H actually doesn't return 0. Yes, H can't correctly
    return 0 if it correctly emulates its input, but you can't drop
    that requirement.

    void P(u32 x)
    {
        if (H(x, x))
          HERE: goto HERE;
        return;
    }

    int main()
    {
        Output("Input_Halts = ", H((u32)P, (u32)P));
    }

    When H returns 0 it does not returns 0 to P it returns 0 to
    main().

    But it also return 0 to the computation P(P), maybe not the copy
    that it is simulating, since it aborts that before it get to it,

    Finally you are not stupid or deceptive.

    If H never returns a value to P then H is not a halting decider; if H
    returns a value of 0 to main() when P halts then H is not a halting
    decider.

    H is not a halting decider; H is a simulation detector, S.

    /Flibble


    In other words you are saying the infintely nested emulation only
    excutes for a few steps and then it stops on its own.


    No, the "infinitely nested emulation" halts when the first H(P,P) that
    P(P) called aborts it simulation.

    When I tell you that an input only halts when it reaches its final state
    and I tell you this many hundreds of times because you are a God damned
    liar you pretend that I never said this.

    --
    Copyright 2022 Pete Olcott

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

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Thu Jun 9 19:09:47 2022
    XPost: comp.theory, sci.logic, sci.math

    On 6/9/22 6:37 PM, olcott wrote:
    On 6/9/2022 5:33 PM, Richard Damon wrote:
    On 6/9/22 6:18 PM, olcott wrote:
    On 6/9/2022 5:15 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:09:08 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 4:54 PM, Richard Damon wrote:
    On 6/9/22 5:29 PM, olcott wrote:
    On 6/9/2022 4:13 PM, Richard Damon wrote:

    On 6/9/22 5:00 PM, olcott wrote:
    On 6/9/2022 3:25 PM, Richard Damon wrote:
    On 6/9/22 4:13 PM, olcott wrote:
    On 6/9/2022 2:57 PM, Richard Damon wrote:
    On 6/9/22 3:52 PM, olcott wrote:
    On 6/9/2022 2:38 PM, Richard Damon wrote:

    On 6/9/22 3:26 PM, olcott wrote:
    On 6/9/2022 1:12 PM, Richard Damon wrote:
    On 6/9/22 1:55 PM, olcott wrote:
    On 6/9/2022 12:46 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:39:32 -0500
    olcott <NoOne@NoWhere.com> wrote:
    On 6/9/2022 12:28 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 12:15:24 -0500
    olcott <NoOne@NoWhere.com> wrote:
    On 6/9/2022 12:06 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 6/9/22 12:54 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 11:34 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 11:47 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> void P(u32 x)
    {
          if (H(x, x))
            HERE: goto HERE; >>>>>>>>>>>>>>>>>>>>>>>>>       return;
    }

    int main()
    {
          P(P);
    }

    _P()
    [000012e7](01)  55              push ebp
    [000012e8](02)  8bec            mov ebp,esp
    [000012ea](03)  8b4508          mov eax,[ebp+08]
    [000012ed](01)  50              push eax
    [000012ee](03)  8b4d08          mov ecx,[ebp+08]
    [000012f1](01)  51              push ecx
    [000012f2](05)  e880feffff      call 00001177 //
    call H [000012f7](03)  83c408          add >>>>>>>>>>>>>>>>>>>>>>>>> esp,+08 [000012fa](02)  85c0            test
    eax,eax [000012fc](02)  7402            jz
    00001300 [000012fe](02)  ebfe            jmp
    000012fe [00001300](01)  5d              pop ebp
    [00001301](01)  c3              ret >>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [00001301] >>>>>>>>>>>>>>>>>>>>>>>>>
    _main()
    [00001307](01)  55              push ebp
    [00001308](02)  8bec            mov ebp,esp
    [0000130a](05)  68e7120000      push 000012e7 //
    push P [0000130f](05)  e8d3ffffff      call >>>>>>>>>>>>>>>>>>>>>>>>> 000012e7 // call P [00001314](03)  83c404 >>>>>>>>>>>>>>>>>>>>>>>>>    add esp,+04 [00001317](02)  33c0 >>>>>>>>>>>>>>>>>>>>>>>>> xor eax,eax [00001319](01)  5d              pop
    ebp [0000131a](01)  c3              ret >>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0020) [0000131a] >>>>>>>>>>>>>>>>>>>>>>>>>
         machine   stack     stack     machine
    assembly address   address   data      code >>>>>>>>>>>>>>>>>>>>>>>>>   language ========  ========  ======== >>>>>>>>>>>>>>>>>>>>>>>>> ========= =============
    [00001307][00102190][00000000] 55         push
    ebp [00001308][00102190][00000000] 8bec >>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp [0000130a][0010218c][000012e7] >>>>>>>>>>>>>>>>>>>>>>>>> 68e7120000 push 000012e7 //
    push P [0000130f][00102188][00001314] e8d3ffffff >>>>>>>>>>>>>>>>>>>>>>>>> call 000012e7
    // call P [000012e7][00102184][00102190] 55 push >>>>>>>>>>>>>>>>>>>>>>>>> ebp // enter executed P
    [000012e8][00102184][00102190] 8bec       mov >>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp [000012ea][00102184][00102190] 8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>   mov eax,[ebp+08]
    [000012ed][00102180][000012e7] 50         push
    eax      //
    push P [000012ee][00102180][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08] [000012f1][0010217c][000012e7] >>>>>>>>>>>>>>>>>>>>>>>>> 51 push ecx      // push P >>>>>>>>>>>>>>>>>>>>>>>>> [000012f2][00102178][000012f7] e880feffff >>>>>>>>>>>>>>>>>>>>>>>>> call 00001177 // call H

    Begin Local Halt Decider Simulation   Execution >>>>>>>>>>>>>>>>>>>>>>>>> Trace Stored
    at:212244 [000012e7][00212230][00212234] 55 push >>>>>>>>>>>>>>>>>>>>>>>>> ebp // enter emulated P
    [000012e8][00212230][00212234] 8bec        mov >>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp [000012ea][00212230][00212234] 8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>    mov eax,[ebp+08]
    [000012ed][0021222c][000012e7] 50          push
    eax      //
    push P [000012ee][0021222c][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>   mov ecx,[ebp+08] [000012f1][00212228][000012e7] >>>>>>>>>>>>>>>>>>>>>>>>> 51 push ecx      // push P >>>>>>>>>>>>>>>>>>>>>>>>> [000012f2][00212224][000012f7] e880feffff >>>>>>>>>>>>>>>>>>>>>>>>> call 00001177 // call H

    So, by what instruction reference manual is a >>>>>>>>>>>>>>>>>>>>>>>> call 00001177
    followedby the execution of the instruction at >>>>>>>>>>>>>>>>>>>>>>>> 000012e7.

    Your "CPU" is broken, or emulation incorrect. >>>>>>>>>>>>>>>>>>>>>>>>
    FAIL.
    [000012e7][0025cc58][0025cc5c] 55          push
    ebp      //
    enter emulated P
    [000012e8][0025cc58][0025cc5c] 8bec        mov >>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp [000012ea][0025cc58][0025cc5c] 8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>    mov eax,[ebp+08]
    [000012ed][0025cc54][000012e7] 50          push
    eax      //
    push P [000012ee][0025cc54][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>   mov ecx,[ebp+08] [000012f1][0025cc50][000012e7] >>>>>>>>>>>>>>>>>>>>>>>>> 51 push ecx      // push P >>>>>>>>>>>>>>>>>>>>>>>>> [000012f2][0025cc4c][000012f7] e880feffff >>>>>>>>>>>>>>>>>>>>>>>>> call 00001177 // call H Local Halt Decider: >>>>>>>>>>>>>>>>>>>>>>>>> Infinite Recursion
    Detected Simulation Stopped

    It is completely obvious that when H(P,P) >>>>>>>>>>>>>>>>>>>>>>>>> correctly emulates
    its input that it must emulate the first seven >>>>>>>>>>>>>>>>>>>>>>>>> instructions of
    P. Because the seventh instruction of P repeats >>>>>>>>>>>>>>>>>>>>>>>>> this process we
    know with complete certainty that the correct >>>>>>>>>>>>>>>>>>>>>>>>> and complete
    emulation of P by H would never reach its final >>>>>>>>>>>>>>>>>>>>>>>>> “ret” instruction, thus never halts. >>>>>>>>>>>>>>>>>>>>>>>>
    Problem, the 7th intruction DOESN't "Just repeat >>>>>>>>>>>>>>>>>>>>>>>> the procedure",
    because that H always has the option to abort its >>>>>>>>>>>>>>>>>>>>>>>> simulation,
    just like this onne did, and return to its P and >>>>>>>>>>>>>>>>>>>>>>>> see it halt.
    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS >>>>>>>>>>>>>>>>>>>>>>> IS NO ACTUAL
    REBUTTAL AT ALL:

    The partial correct x86 emulation of the input to >>>>>>>>>>>>>>>>>>>>>>> H(P,P) conclusively proves that the complete and >>>>>>>>>>>>>>>>>>>>>>> correct x86 emulation
    would never stop running.

    You SAY that, but you don't answer the actual >>>>>>>>>>>>>>>>>>>>>> questions about HOW.

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS >>>>>>>>>>>>>>>>>>>>> NO EVIDENCE
    WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE THAT >>>>>>>>>>>>>>>>>>>>> THE CORRECT
    PARTIAL EMULATION OF THE INPUT TO H(P,P) >>>>>>>>>>>>>>>>>>>>> CONCLUSIVELY PROVES THAT
    THE CORRECT AND COMPLETE X86 EMULATION OF THE INPUT >>>>>>>>>>>>>>>>>>>>> TO H(P,P)
    WOULD NEVER STOP RUNNING.

    It is completely obvious that when H(P,P) correctly >>>>>>>>>>>>>>>>>>>>> emulates its
    input that it must emulate the first seven >>>>>>>>>>>>>>>>>>>>> instructions of P.
    Because the seventh instruction of P repeats this >>>>>>>>>>>>>>>>>>>>> process we know
    with complete certainty that the correct and >>>>>>>>>>>>>>>>>>>>> complete emulation of
    P by H would never reach its final “ret” >>>>>>>>>>>>>>>>>>>>> instruction, thus never
    halts.

    If P should have halted (i.e. no infinite loop) then >>>>>>>>>>>>>>>>>>>> your simulation
    detector, S (not H), gets the answer wrong.  You S is >>>>>>>>>>>>>>>>>>>> NOT a halting
    decider.

    /Flibble

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS >>>>>>>>>>>>>>>>>>> NO ACTUAL
    REBUTTAL AT ALL.

    _P()
    [00001352](01)  55              push ebp >>>>>>>>>>>>>>>>>>> [00001353](02)  8bec            mov ebp,esp >>>>>>>>>>>>>>>>>>> [00001355](03)  8b4508          mov eax,[ebp+08] >>>>>>>>>>>>>>>>>>> [00001358](01)  50              push eax      // push P
    [00001359](03)  8b4d08          mov ecx,[ebp+08] >>>>>>>>>>>>>>>>>>> [0000135c](01)  51              push ecx      // push P
    [0000135d](05)  e840feffff      call 000011a2 // call H
    [00001362](03)  83c408          add esp,+08 >>>>>>>>>>>>>>>>>>> [00001365](02)  85c0            test eax,eax >>>>>>>>>>>>>>>>>>> [00001367](02)  7402            jz 0000136b >>>>>>>>>>>>>>>>>>> [00001369](02)  ebfe            jmp 00001369 >>>>>>>>>>>>>>>>>>> [0000136b](01)  5d              pop ebp >>>>>>>>>>>>>>>>>>> [0000136c](01)  c3              ret >>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]

    It is completely obvious that when H(P,P) correctly >>>>>>>>>>>>>>>>>>> emulates its
    input that it must emulate the first seven >>>>>>>>>>>>>>>>>>> instructions of P. Because
    the seventh instruction of P repeats this process we >>>>>>>>>>>>>>>>>>> know with
    complete certainty that the correct and complete >>>>>>>>>>>>>>>>>>> emulation of P by H
    would never reach its final “ret” instruction, thus >>>>>>>>>>>>>>>>>>> never halts.

    We are going around and around and around in circles. I >>>>>>>>>>>>>>>>>> will try again:

    If you replace the opcodes "EB FE" at 00001369 with the >>>>>>>>>>>>>>>>>> opcodes "90 90"
    then your H gets the answer wrong: P should have halted. >>>>>>>>>>>>>>>>>>
    /Flibble

    As I already said before this is merely your >>>>>>>>>>>>>>>>> cluelessness that when H(P,P) is invoked the correct x86 >>>>>>>>>>>>>>>>> emulation of the input to H(P,P) makes and code after >>>>>>>>>>>>>>>>> [0000135d] unreachable.

    Wrong, because when that H return the value 0, it will >>>>>>>>>>>>>>>> get there.
    Like I said people that are dumber than a box of rocks >>>>>>>>>>>>>>> won't be able to correctly understand this.

    When H(P,P) is invoked the correctly emulated input to >>>>>>>>>>>>>>> H(P,P) cannot possibly reach any instruction beyond >>>>>>>>>>>>>>> [0000135d].

    So, you are defining that you H(P,P) never returns because >>>>>>>>>>>>>> it is caught in the infinite rcursion.

    Thats fine, just says it can't be the correctly answering >>>>>>>>>>>>>> decider you claim it to be.

    I have corrected you on this too many times.

    How. You need to define what H(P,P) actually does.

    I have explained that too many times.

    To understand that H(P,P)==0 is correct we only need to know >>>>>>>>>>> that H performs a correct x86 emulation of its input and then >>>>>>>>>>> examine the execution trace.

    And a CORRECT emulation of the code will Halt if H(P,P) returns >>>>>>>>>> 0, which it can only do if it does not actually do a correct >>>>>>>>>> emulation

    The correctly emulated input to H(P,P) never gets past its
    machine address [0000135d].


    Only if H actually doesn't return 0. Yes, H can't correctly
    return 0 if it correctly emulates its input, but you can't drop >>>>>>>> that requirement.

    void P(u32 x)
    {
        if (H(x, x))
          HERE: goto HERE;
        return;
    }

    int main()
    {
        Output("Input_Halts = ", H((u32)P, (u32)P));
    }

    When H returns 0 it does not returns 0 to P it returns 0 to
    main().

    But it also return 0 to the computation P(P), maybe not the copy
    that it is simulating, since it aborts that before it get to it,

    Finally you are not stupid or deceptive.

    If H never returns a value to P then H is not a halting decider; if H
    returns a value of 0 to main() when P halts then H is not a halting
    decider.

    H is not a halting decider; H is a simulation detector, S.

    /Flibble


    In other words you are saying the infintely nested emulation only
    excutes for a few steps and then it stops on its own.


    No, the "infinitely nested emulation" halts when the first H(P,P) that
    P(P) called aborts it simulation.

    When I tell you that an input only halts when it reaches its final state
    and I tell you this many hundreds of times because you are a God damned
    liar you pretend that I never said this.


    Right, and when H(P,P) returns 0, the P that called it reaches its final state/the ret instrucion.

    The key is that the CORRECT simulation doesn't stop running just because
    H aborts it simulation.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Thu Jun 9 19:12:41 2022
    XPost: comp.theory, sci.logic, sci.math

    On 6/9/22 6:34 PM, olcott wrote:
    On 6/9/2022 5:17 PM, Richard Damon wrote:
    On 6/9/22 6:09 PM, olcott wrote:
    On 6/9/2022 4:54 PM, Richard Damon wrote:
    On 6/9/22 5:29 PM, olcott wrote:
    On 6/9/2022 4:13 PM, Richard Damon wrote:

    On 6/9/22 5:00 PM, olcott wrote:
    On 6/9/2022 3:25 PM, Richard Damon wrote:
    On 6/9/22 4:13 PM, olcott wrote:
    On 6/9/2022 2:57 PM, Richard Damon wrote:
    On 6/9/22 3:52 PM, olcott wrote:
    On 6/9/2022 2:38 PM, Richard Damon wrote:

    On 6/9/22 3:26 PM, olcott wrote:
    On 6/9/2022 1:12 PM, Richard Damon wrote:
    On 6/9/22 1:55 PM, olcott wrote:
    On 6/9/2022 12:46 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:39:32 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 12:28 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:15:24 -0500
    olcott <NoOne@NoWhere.com> wrote:
    On 6/9/2022 12:06 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 6/9/22 12:54 PM, olcott wrote:
    On 6/9/2022 11:34 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 6/9/22 11:47 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> void P(u32 x)
    {
         if (H(x, x))
           HERE: goto HERE;
         return;
    }

    int main()
    {
         P(P);
    }

    _P()
    [000012e7](01)  55              push ebp >>>>>>>>>>>>>>>>>>>>>>> [000012e8](02)  8bec            mov ebp,esp >>>>>>>>>>>>>>>>>>>>>>> [000012ea](03)  8b4508          mov eax,[ebp+08]
    [000012ed](01)  50              push eax >>>>>>>>>>>>>>>>>>>>>>> [000012ee](03)  8b4d08          mov ecx,[ebp+08]
    [000012f1](01)  51              push ecx >>>>>>>>>>>>>>>>>>>>>>> [000012f2](05)  e880feffff      call 00001177 // >>>>>>>>>>>>>>>>>>>>>>> call H
    [000012f7](03)  83c408          add esp,+08 >>>>>>>>>>>>>>>>>>>>>>> [000012fa](02)  85c0            test eax,eax
    [000012fc](02)  7402            jz 00001300 >>>>>>>>>>>>>>>>>>>>>>> [000012fe](02)  ebfe            jmp 000012fe
    [00001300](01)  5d              pop ebp >>>>>>>>>>>>>>>>>>>>>>> [00001301](01)  c3              ret >>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [00001301]

    _main()
    [00001307](01)  55              push ebp >>>>>>>>>>>>>>>>>>>>>>> [00001308](02)  8bec            mov ebp,esp >>>>>>>>>>>>>>>>>>>>>>> [0000130a](05)  68e7120000      push 000012e7 // >>>>>>>>>>>>>>>>>>>>>>> push P
    [0000130f](05)  e8d3ffffff      call 000012e7 // >>>>>>>>>>>>>>>>>>>>>>> call P
    [00001314](03)  83c404          add esp,+04 >>>>>>>>>>>>>>>>>>>>>>> [00001317](02)  33c0            xor eax,eax >>>>>>>>>>>>>>>>>>>>>>> [00001319](01)  5d              pop ebp >>>>>>>>>>>>>>>>>>>>>>> [0000131a](01)  c3              ret >>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0020) [0000131a]

        machine   stack     stack     machine >>>>>>>>>>>>>>>>>>>>>>> assembly
        address   address   data      code >>>>>>>>>>>>>>>>>>>>>>> language
        ========  ========  ========  ========= >>>>>>>>>>>>>>>>>>>>>>> =============
    [00001307][00102190][00000000] 55         push ebp
    [00001308][00102190][00000000] 8bec       mov >>>>>>>>>>>>>>>>>>>>>>> ebp,esp
    [0000130a][0010218c][000012e7] 68e7120000 push >>>>>>>>>>>>>>>>>>>>>>> 000012e7 //
    push P [0000130f][00102188][00001314] e8d3ffffff >>>>>>>>>>>>>>>>>>>>>>> call 000012e7
    // call P [000012e7][00102184][00102190] 55 push ebp >>>>>>>>>>>>>>>>>>>>>>>     // enter executed P
    [000012e8][00102184][00102190] 8bec       mov >>>>>>>>>>>>>>>>>>>>>>> ebp,esp
    [000012ea][00102184][00102190] 8b4508     mov >>>>>>>>>>>>>>>>>>>>>>> eax,[ebp+08]
    [000012ed][00102180][000012e7] 50         push >>>>>>>>>>>>>>>>>>>>>>> eax      //
    push P [000012ee][00102180][000012e7] 8b4d08     mov
    ecx,[ebp+08] [000012f1][0010217c][000012e7] 51 push >>>>>>>>>>>>>>>>>>>>>>> ecx      // push P [000012f2][00102178][000012f7] >>>>>>>>>>>>>>>>>>>>>>> e880feffff
    call 00001177 // call H

    Begin Local Halt Decider Simulation   Execution >>>>>>>>>>>>>>>>>>>>>>> Trace Stored
    at:212244 [000012e7][00212230][00212234] 55 push ebp >>>>>>>>>>>>>>>>>>>>>>>     // enter emulated P
    [000012e8][00212230][00212234] 8bec        mov >>>>>>>>>>>>>>>>>>>>>>> ebp,esp
    [000012ea][00212230][00212234] 8b4508      mov >>>>>>>>>>>>>>>>>>>>>>> eax,[ebp+08]
    [000012ed][0021222c][000012e7] 50          push
    eax      //
    push P [000012ee][0021222c][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>> mov
    ecx,[ebp+08] [000012f1][00212228][000012e7] 51 push >>>>>>>>>>>>>>>>>>>>>>> ecx      // push P [000012f2][00212224][000012f7] >>>>>>>>>>>>>>>>>>>>>>> e880feffff
    call 00001177 // call H

    So, by what instruction reference manual is a call >>>>>>>>>>>>>>>>>>>>>> 00001177
    followedby the execution of the instruction at >>>>>>>>>>>>>>>>>>>>>> 000012e7.

    Your "CPU" is broken, or emulation incorrect. >>>>>>>>>>>>>>>>>>>>>>
    FAIL.
    [000012e7][0025cc58][0025cc5c] 55          push
    ebp      //
    enter emulated P
    [000012e8][0025cc58][0025cc5c] 8bec        mov >>>>>>>>>>>>>>>>>>>>>>> ebp,esp
    [000012ea][0025cc58][0025cc5c] 8b4508      mov >>>>>>>>>>>>>>>>>>>>>>> eax,[ebp+08]
    [000012ed][0025cc54][000012e7] 50          push
    eax      //
    push P [000012ee][0025cc54][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>> mov
    ecx,[ebp+08] [000012f1][0025cc50][000012e7] 51 push >>>>>>>>>>>>>>>>>>>>>>> ecx      // push P [000012f2][0025cc4c][000012f7] >>>>>>>>>>>>>>>>>>>>>>> e880feffff
    call 00001177 // call H Local Halt Decider: >>>>>>>>>>>>>>>>>>>>>>> Infinite Recursion
    Detected Simulation Stopped

    It is completely obvious that when H(P,P) >>>>>>>>>>>>>>>>>>>>>>> correctly emulates
    its input that it must emulate the first seven >>>>>>>>>>>>>>>>>>>>>>> instructions of
    P. Because the seventh instruction of P repeats >>>>>>>>>>>>>>>>>>>>>>> this process we
    know with complete certainty that the correct and >>>>>>>>>>>>>>>>>>>>>>> complete
    emulation of P by H would never reach its final >>>>>>>>>>>>>>>>>>>>>>> “ret”
    instruction, thus never halts.

    Problem, the 7th intruction DOESN't "Just repeat >>>>>>>>>>>>>>>>>>>>>> the procedure",
    because that H always has the option to abort its >>>>>>>>>>>>>>>>>>>>>> simulation,
    just like this onne did, and return to its P and >>>>>>>>>>>>>>>>>>>>>> see it halt.
    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS >>>>>>>>>>>>>>>>>>>>> IS NO ACTUAL
    REBUTTAL AT ALL:

    The partial correct x86 emulation of the input to >>>>>>>>>>>>>>>>>>>>> H(P,P)
    conclusively proves that the complete and correct >>>>>>>>>>>>>>>>>>>>> x86 emulation
    would never stop running.


    You SAY that, but you don't answer the actual >>>>>>>>>>>>>>>>>>>> questions about HOW.

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS >>>>>>>>>>>>>>>>>>> NO EVIDENCE
    WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE THAT THE >>>>>>>>>>>>>>>>>>> CORRECT
    PARTIAL EMULATION OF THE INPUT TO H(P,P) CONCLUSIVELY >>>>>>>>>>>>>>>>>>> PROVES THAT
    THE CORRECT AND COMPLETE X86 EMULATION OF THE INPUT >>>>>>>>>>>>>>>>>>> TO H(P,P)
    WOULD NEVER STOP RUNNING.

    It is completely obvious that when H(P,P) correctly >>>>>>>>>>>>>>>>>>> emulates its
    input that it must emulate the first seven >>>>>>>>>>>>>>>>>>> instructions of P.
    Because the seventh instruction of P repeats this >>>>>>>>>>>>>>>>>>> process we know
    with complete certainty that the correct and complete >>>>>>>>>>>>>>>>>>> emulation of
    P by H would never reach its final “ret” instruction, >>>>>>>>>>>>>>>>>>> thus never
    halts.

    If P should have halted (i.e. no infinite loop) then >>>>>>>>>>>>>>>>>> your simulation
    detector, S (not H), gets the answer wrong.  You S is >>>>>>>>>>>>>>>>>> NOT a halting
    decider.

    /Flibble

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS NO >>>>>>>>>>>>>>>>> ACTUAL
    REBUTTAL AT ALL.

    _P()
    [00001352](01)  55              push ebp >>>>>>>>>>>>>>>>> [00001353](02)  8bec            mov ebp,esp >>>>>>>>>>>>>>>>> [00001355](03)  8b4508          mov eax,[ebp+08] >>>>>>>>>>>>>>>>> [00001358](01)  50              push eax      // push P
    [00001359](03)  8b4d08          mov ecx,[ebp+08] >>>>>>>>>>>>>>>>> [0000135c](01)  51              push ecx      // push P
    [0000135d](05)  e840feffff      call 000011a2 // call H >>>>>>>>>>>>>>>>> [00001362](03)  83c408          add esp,+08 >>>>>>>>>>>>>>>>> [00001365](02)  85c0            test eax,eax >>>>>>>>>>>>>>>>> [00001367](02)  7402            jz 0000136b >>>>>>>>>>>>>>>>> [00001369](02)  ebfe            jmp 00001369 >>>>>>>>>>>>>>>>> [0000136b](01)  5d              pop ebp >>>>>>>>>>>>>>>>> [0000136c](01)  c3              ret >>>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]

    It is completely obvious that when H(P,P) correctly >>>>>>>>>>>>>>>>> emulates its
    input that it must emulate the first seven instructions >>>>>>>>>>>>>>>>> of P. Because
    the seventh instruction of P repeats this process we >>>>>>>>>>>>>>>>> know with
    complete certainty that the correct and complete >>>>>>>>>>>>>>>>> emulation of P by H
    would never reach its final “ret” instruction, thus >>>>>>>>>>>>>>>>> never halts.

    We are going around and around and around in circles. I >>>>>>>>>>>>>>>> will try again:

    If you replace the opcodes "EB FE" at 00001369 with the >>>>>>>>>>>>>>>> opcodes "90 90"
    then your H gets the answer wrong: P should have halted. >>>>>>>>>>>>>>>>
    /Flibble


    As I already said before this is merely your cluelessness >>>>>>>>>>>>>>> that when H(P,P) is invoked the correct x86 emulation of >>>>>>>>>>>>>>> the input to H(P,P) makes and code after [0000135d] >>>>>>>>>>>>>>> unreachable.

    Wrong, because when that H return the value 0, it will get >>>>>>>>>>>>>> there.
    Like I said people that are dumber than a box of rocks >>>>>>>>>>>>> won't be able to correctly understand this.

    When H(P,P) is invoked the correctly emulated input to >>>>>>>>>>>>> H(P,P) cannot possibly reach any instruction beyond
    [0000135d].

    So, you are defining that you H(P,P) never returns because >>>>>>>>>>>> it is caught in the infinite rcursion.

    Thats fine, just says it can't be the correctly answering >>>>>>>>>>>> decider you claim it to be.

    I have corrected you on this too many times.


    How. You need to define what H(P,P) actually does.

    I have explained that too many times.

    To understand that H(P,P)==0 is correct we only need to know >>>>>>>>> that H performs a correct x86 emulation of its input and then >>>>>>>>> examine the execution trace.

    And a CORRECT emulation of the code will Halt if H(P,P) returns >>>>>>>> 0, which it can only do if it does not actually do a correct
    emulation


    The correctly emulated input to H(P,P) never gets past its
    machine address [0000135d].



    Only if H actually doesn't return 0. Yes, H can't correctly return >>>>>> 0 if it correctly emulates its input, but you can't drop that
    requirement.

    void P(u32 x)
    {
       if (H(x, x))
         HERE: goto HERE;
       return;
    }

    int main()
    {
       Output("Input_Halts = ", H((u32)P, (u32)P));
    }

    When H returns 0 it does not returns 0 to P it returns 0 to main().

    But it also return 0 to the computation P(P), maybe not the copy
    that it is simulating, since it aborts that before it get to it,

    Finally you are not stupid or deceptive.




    So, you agree that your H(P,P) that returns a 0, claiming it to be
    correct, also returns that 0 to P(P) and thus P(P) Halts, and thus
    H(P,P) is INCORRECT in saying that its input represents a non-halting
    computation?

    That you are waaaay too stupid to understand that I correctly proved
    that P(P) and the correct simulatuon of the input to H(P,P) actually
    have different halting behavior is no actual rebuttal at all.



    No, you didn't. Wanna try again. You just make that claim without an
    actual proof.

    The ONLY way thst can happen is if H isn't actually a computation. If I remember your proof, all you did was prove that your H isn't actoally a computation.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Richard Damon on Thu Jun 9 18:14:35 2022
    XPost: comp.theory, sci.logic, sci.math

    On 6/9/2022 6:09 PM, Richard Damon wrote:
    On 6/9/22 6:37 PM, olcott wrote:
    On 6/9/2022 5:33 PM, Richard Damon wrote:
    On 6/9/22 6:18 PM, olcott wrote:
    On 6/9/2022 5:15 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:09:08 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 4:54 PM, Richard Damon wrote:
    On 6/9/22 5:29 PM, olcott wrote:
    On 6/9/2022 4:13 PM, Richard Damon wrote:

    On 6/9/22 5:00 PM, olcott wrote:
    On 6/9/2022 3:25 PM, Richard Damon wrote:
    On 6/9/22 4:13 PM, olcott wrote:
    On 6/9/2022 2:57 PM, Richard Damon wrote:
    On 6/9/22 3:52 PM, olcott wrote:
    On 6/9/2022 2:38 PM, Richard Damon wrote:

    On 6/9/22 3:26 PM, olcott wrote:
    On 6/9/2022 1:12 PM, Richard Damon wrote:
    On 6/9/22 1:55 PM, olcott wrote:
    On 6/9/2022 12:46 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:39:32 -0500
    olcott <NoOne@NoWhere.com> wrote:
    On 6/9/2022 12:28 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 12:15:24 -0500
    olcott <NoOne@NoWhere.com> wrote:
    On 6/9/2022 12:06 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 12:54 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 11:34 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 11:47 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> void P(u32 x)
    {
          if (H(x, x))
            HERE: goto HERE; >>>>>>>>>>>>>>>>>>>>>>>>>>       return;
    }

    int main()
    {
          P(P);
    }

    _P()
    [000012e7](01)  55              push ebp
    [000012e8](02)  8bec            mov ebp,esp
    [000012ea](03)  8b4508          mov eax,[ebp+08]
    [000012ed](01)  50              push eax
    [000012ee](03)  8b4d08          mov ecx,[ebp+08]
    [000012f1](01)  51              push ecx
    [000012f2](05)  e880feffff      call 00001177 //
    call H [000012f7](03)  83c408          add >>>>>>>>>>>>>>>>>>>>>>>>>> esp,+08 [000012fa](02)  85c0            test
    eax,eax [000012fc](02)  7402            jz
    00001300 [000012fe](02)  ebfe            jmp
    000012fe [00001300](01)  5d              pop ebp
    [00001301](01)  c3              ret >>>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [00001301] >>>>>>>>>>>>>>>>>>>>>>>>>>
    _main()
    [00001307](01)  55              push ebp
    [00001308](02)  8bec            mov ebp,esp
    [0000130a](05)  68e7120000      push 000012e7 //
    push P [0000130f](05)  e8d3ffffff      call >>>>>>>>>>>>>>>>>>>>>>>>>> 000012e7 // call P [00001314](03)  83c404 >>>>>>>>>>>>>>>>>>>>>>>>>>    add esp,+04 [00001317](02)  33c0 >>>>>>>>>>>>>>>>>>>>>>>>>> xor eax,eax [00001319](01)  5d              pop
    ebp [0000131a](01)  c3              ret
    Size in bytes:(0020) [0000131a] >>>>>>>>>>>>>>>>>>>>>>>>>>
         machine   stack     stack     machine
    assembly address   address   data      code >>>>>>>>>>>>>>>>>>>>>>>>>>   language ========  ========  ======== >>>>>>>>>>>>>>>>>>>>>>>>>> ========= =============
    [00001307][00102190][00000000] 55         push
    ebp [00001308][00102190][00000000] 8bec >>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp [0000130a][0010218c][000012e7] >>>>>>>>>>>>>>>>>>>>>>>>>> 68e7120000 push 000012e7 // >>>>>>>>>>>>>>>>>>>>>>>>>> push P [0000130f][00102188][00001314] e8d3ffffff >>>>>>>>>>>>>>>>>>>>>>>>>> call 000012e7
    // call P [000012e7][00102184][00102190] 55 push >>>>>>>>>>>>>>>>>>>>>>>>>> ebp // enter executed P
    [000012e8][00102184][00102190] 8bec       mov >>>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp [000012ea][00102184][00102190] 8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>>   mov eax,[ebp+08]
    [000012ed][00102180][000012e7] 50         push
    eax      //
    push P [000012ee][00102180][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08] [000012f1][0010217c][000012e7] >>>>>>>>>>>>>>>>>>>>>>>>>> 51 push ecx      // push P >>>>>>>>>>>>>>>>>>>>>>>>>> [000012f2][00102178][000012f7] e880feffff >>>>>>>>>>>>>>>>>>>>>>>>>> call 00001177 // call H

    Begin Local Halt Decider Simulation   Execution >>>>>>>>>>>>>>>>>>>>>>>>>> Trace Stored
    at:212244 [000012e7][00212230][00212234] 55 push >>>>>>>>>>>>>>>>>>>>>>>>>> ebp // enter emulated P
    [000012e8][00212230][00212234] 8bec        mov
    ebp,esp [000012ea][00212230][00212234] 8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>>    mov eax,[ebp+08]
    [000012ed][0021222c][000012e7] 50          push
    eax      //
    push P [000012ee][0021222c][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>>   mov ecx,[ebp+08] [000012f1][00212228][000012e7] >>>>>>>>>>>>>>>>>>>>>>>>>> 51 push ecx      // push P >>>>>>>>>>>>>>>>>>>>>>>>>> [000012f2][00212224][000012f7] e880feffff >>>>>>>>>>>>>>>>>>>>>>>>>> call 00001177 // call H

    So, by what instruction reference manual is a >>>>>>>>>>>>>>>>>>>>>>>>> call 00001177
    followedby the execution of the instruction at >>>>>>>>>>>>>>>>>>>>>>>>> 000012e7.

    Your "CPU" is broken, or emulation incorrect. >>>>>>>>>>>>>>>>>>>>>>>>>
    FAIL.
    [000012e7][0025cc58][0025cc5c] 55          push
    ebp      //
    enter emulated P
    [000012e8][0025cc58][0025cc5c] 8bec        mov
    ebp,esp [000012ea][0025cc58][0025cc5c] 8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>>    mov eax,[ebp+08]
    [000012ed][0025cc54][000012e7] 50          push
    eax      //
    push P [000012ee][0025cc54][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>>   mov ecx,[ebp+08] [000012f1][0025cc50][000012e7] >>>>>>>>>>>>>>>>>>>>>>>>>> 51 push ecx      // push P >>>>>>>>>>>>>>>>>>>>>>>>>> [000012f2][0025cc4c][000012f7] e880feffff >>>>>>>>>>>>>>>>>>>>>>>>>> call 00001177 // call H Local Halt Decider: >>>>>>>>>>>>>>>>>>>>>>>>>> Infinite Recursion
    Detected Simulation Stopped >>>>>>>>>>>>>>>>>>>>>>>>>>
    It is completely obvious that when H(P,P) >>>>>>>>>>>>>>>>>>>>>>>>>> correctly emulates
    its input that it must emulate the first seven >>>>>>>>>>>>>>>>>>>>>>>>>> instructions of
    P. Because the seventh instruction of P repeats >>>>>>>>>>>>>>>>>>>>>>>>>> this process we
    know with complete certainty that the correct >>>>>>>>>>>>>>>>>>>>>>>>>> and complete
    emulation of P by H would never reach its final >>>>>>>>>>>>>>>>>>>>>>>>>> “ret” instruction, thus never halts. >>>>>>>>>>>>>>>>>>>>>>>>>
    Problem, the 7th intruction DOESN't "Just repeat >>>>>>>>>>>>>>>>>>>>>>>>> the procedure",
    because that H always has the option to abort its >>>>>>>>>>>>>>>>>>>>>>>>> simulation,
    just like this onne did, and return to its P and >>>>>>>>>>>>>>>>>>>>>>>>> see it halt.
    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS >>>>>>>>>>>>>>>>>>>>>>>> IS NO ACTUAL
    REBUTTAL AT ALL:

    The partial correct x86 emulation of the input to >>>>>>>>>>>>>>>>>>>>>>>> H(P,P) conclusively proves that the complete and >>>>>>>>>>>>>>>>>>>>>>>> correct x86 emulation
    would never stop running.

    You SAY that, but you don't answer the actual >>>>>>>>>>>>>>>>>>>>>>> questions about HOW.

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS >>>>>>>>>>>>>>>>>>>>>> NO EVIDENCE
    WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE THAT >>>>>>>>>>>>>>>>>>>>>> THE CORRECT
    PARTIAL EMULATION OF THE INPUT TO H(P,P) >>>>>>>>>>>>>>>>>>>>>> CONCLUSIVELY PROVES THAT
    THE CORRECT AND COMPLETE X86 EMULATION OF THE INPUT >>>>>>>>>>>>>>>>>>>>>> TO H(P,P)
    WOULD NEVER STOP RUNNING.

    It is completely obvious that when H(P,P) correctly >>>>>>>>>>>>>>>>>>>>>> emulates its
    input that it must emulate the first seven >>>>>>>>>>>>>>>>>>>>>> instructions of P.
    Because the seventh instruction of P repeats this >>>>>>>>>>>>>>>>>>>>>> process we know
    with complete certainty that the correct and >>>>>>>>>>>>>>>>>>>>>> complete emulation of
    P by H would never reach its final “ret” >>>>>>>>>>>>>>>>>>>>>> instruction, thus never
    halts.

    If P should have halted (i.e. no infinite loop) then >>>>>>>>>>>>>>>>>>>>> your simulation
    detector, S (not H), gets the answer wrong.  You S is >>>>>>>>>>>>>>>>>>>>> NOT a halting
    decider.

    /Flibble

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS >>>>>>>>>>>>>>>>>>>> NO ACTUAL
    REBUTTAL AT ALL.

    _P()
    [00001352](01)  55              push ebp >>>>>>>>>>>>>>>>>>>> [00001353](02)  8bec            mov ebp,esp >>>>>>>>>>>>>>>>>>>> [00001355](03)  8b4508          mov eax,[ebp+08] >>>>>>>>>>>>>>>>>>>> [00001358](01)  50              push eax      // push P
    [00001359](03)  8b4d08          mov ecx,[ebp+08] >>>>>>>>>>>>>>>>>>>> [0000135c](01)  51              push ecx      // push P
    [0000135d](05)  e840feffff      call 000011a2 // call H
    [00001362](03)  83c408          add esp,+08 >>>>>>>>>>>>>>>>>>>> [00001365](02)  85c0            test eax,eax >>>>>>>>>>>>>>>>>>>> [00001367](02)  7402            jz 0000136b >>>>>>>>>>>>>>>>>>>> [00001369](02)  ebfe            jmp 00001369 >>>>>>>>>>>>>>>>>>>> [0000136b](01)  5d              pop ebp >>>>>>>>>>>>>>>>>>>> [0000136c](01)  c3              ret >>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]

    It is completely obvious that when H(P,P) correctly >>>>>>>>>>>>>>>>>>>> emulates its
    input that it must emulate the first seven >>>>>>>>>>>>>>>>>>>> instructions of P. Because
    the seventh instruction of P repeats this process we >>>>>>>>>>>>>>>>>>>> know with
    complete certainty that the correct and complete >>>>>>>>>>>>>>>>>>>> emulation of P by H
    would never reach its final “ret” instruction, thus >>>>>>>>>>>>>>>>>>>> never halts.

    We are going around and around and around in circles. I >>>>>>>>>>>>>>>>>>> will try again:

    If you replace the opcodes "EB FE" at 00001369 with the >>>>>>>>>>>>>>>>>>> opcodes "90 90"
    then your H gets the answer wrong: P should have halted. >>>>>>>>>>>>>>>>>>>
    /Flibble

    As I already said before this is merely your >>>>>>>>>>>>>>>>>> cluelessness that when H(P,P) is invoked the correct x86 >>>>>>>>>>>>>>>>>> emulation of the input to H(P,P) makes and code after >>>>>>>>>>>>>>>>>> [0000135d] unreachable.

    Wrong, because when that H return the value 0, it will >>>>>>>>>>>>>>>>> get there.
    Like I said people that are dumber than a box of rocks >>>>>>>>>>>>>>>> won't be able to correctly understand this.

    When H(P,P) is invoked the correctly emulated input to >>>>>>>>>>>>>>>> H(P,P) cannot possibly reach any instruction beyond >>>>>>>>>>>>>>>> [0000135d].

    So, you are defining that you H(P,P) never returns because >>>>>>>>>>>>>>> it is caught in the infinite rcursion.

    Thats fine, just says it can't be the correctly answering >>>>>>>>>>>>>>> decider you claim it to be.

    I have corrected you on this too many times.

    How. You need to define what H(P,P) actually does.

    I have explained that too many times.

    To understand that H(P,P)==0 is correct we only need to know >>>>>>>>>>>> that H performs a correct x86 emulation of its input and then >>>>>>>>>>>> examine the execution trace.

    And a CORRECT emulation of the code will Halt if H(P,P) returns >>>>>>>>>>> 0, which it can only do if it does not actually do a correct >>>>>>>>>>> emulation

    The correctly emulated input to H(P,P) never gets past its >>>>>>>>>> machine address [0000135d].


    Only if H actually doesn't return 0. Yes, H can't correctly
    return 0 if it correctly emulates its input, but you can't drop >>>>>>>>> that requirement.

    void P(u32 x)
    {
        if (H(x, x))
          HERE: goto HERE;
        return;
    }

    int main()
    {
        Output("Input_Halts = ", H((u32)P, (u32)P));
    }

    When H returns 0 it does not returns 0 to P it returns 0 to
    main().

    But it also return 0 to the computation P(P), maybe not the copy >>>>>>> that it is simulating, since it aborts that before it get to it,

    Finally you are not stupid or deceptive.

    If H never returns a value to P then H is not a halting decider; if H >>>>> returns a value of 0 to main() when P halts then H is not a halting
    decider.

    H is not a halting decider; H is a simulation detector, S.

    /Flibble


    In other words you are saying the infintely nested emulation only
    excutes for a few steps and then it stops on its own.


    No, the "infinitely nested emulation" halts when the first H(P,P)
    that P(P) called aborts it simulation.

    When I tell you that an input only halts when it reaches its final
    state and I tell you this many hundreds of times because you are a God
    damned liar you pretend that I never said this.


    Right, and when H(P,P) returns 0, the P that called it reaches its final state/the ret instrucion.

    YOU GOD DAMNED LIAR main() calls H(P,P) and H returns to main()

    void P(u32 x)
    {
    if (H(x, x))
    HERE: goto HERE;
    return;
    }

    int main()
    {
    Output("Input_Halts = ", H((u32)P, (u32)P));
    }


    --
    Copyright 2022 Pete Olcott

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

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Thu Jun 9 19:17:51 2022
    XPost: comp.theory, sci.logic, sci.math

    On 6/9/22 7:14 PM, olcott wrote:
    On 6/9/2022 6:09 PM, Richard Damon wrote:
    On 6/9/22 6:37 PM, olcott wrote:
    On 6/9/2022 5:33 PM, Richard Damon wrote:
    On 6/9/22 6:18 PM, olcott wrote:
    On 6/9/2022 5:15 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:09:08 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 4:54 PM, Richard Damon wrote:
    On 6/9/22 5:29 PM, olcott wrote:
    On 6/9/2022 4:13 PM, Richard Damon wrote:

    On 6/9/22 5:00 PM, olcott wrote:
    On 6/9/2022 3:25 PM, Richard Damon wrote:
    On 6/9/22 4:13 PM, olcott wrote:
    On 6/9/2022 2:57 PM, Richard Damon wrote:
    On 6/9/22 3:52 PM, olcott wrote:
    On 6/9/2022 2:38 PM, Richard Damon wrote:

    On 6/9/22 3:26 PM, olcott wrote:
    On 6/9/2022 1:12 PM, Richard Damon wrote:
    On 6/9/22 1:55 PM, olcott wrote:
    On 6/9/2022 12:46 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 12:39:32 -0500
    olcott <NoOne@NoWhere.com> wrote:
    On 6/9/2022 12:28 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 12:15:24 -0500
    olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 12:06 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 12:54 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 11:34 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 11:47 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> void P(u32 x)
    {
          if (H(x, x))
            HERE: goto HERE; >>>>>>>>>>>>>>>>>>>>>>>>>>>       return;
    }

    int main()
    {
          P(P);
    }

    _P()
    [000012e7](01)  55              push ebp
    [000012e8](02)  8bec            mov ebp,esp
    [000012ea](03)  8b4508          mov eax,[ebp+08]
    [000012ed](01)  50              push eax
    [000012ee](03)  8b4d08          mov ecx,[ebp+08]
    [000012f1](01)  51              push ecx
    [000012f2](05)  e880feffff      call 00001177 //
    call H [000012f7](03)  83c408          add
    esp,+08 [000012fa](02)  85c0            test
    eax,eax [000012fc](02)  7402            jz
    00001300 [000012fe](02)  ebfe            jmp
    000012fe [00001300](01)  5d              pop ebp
    [00001301](01)  c3              ret >>>>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [00001301] >>>>>>>>>>>>>>>>>>>>>>>>>>>
    _main()
    [00001307](01)  55              push ebp
    [00001308](02)  8bec            mov ebp,esp
    [0000130a](05)  68e7120000      push 000012e7 //
    push P [0000130f](05)  e8d3ffffff      call >>>>>>>>>>>>>>>>>>>>>>>>>>> 000012e7 // call P [00001314](03)  83c404 >>>>>>>>>>>>>>>>>>>>>>>>>>>    add esp,+04 [00001317](02)  33c0 >>>>>>>>>>>>>>>>>>>>>>>>>>> xor eax,eax [00001319](01)  5d              pop
    ebp [0000131a](01)  c3              ret
    Size in bytes:(0020) [0000131a] >>>>>>>>>>>>>>>>>>>>>>>>>>>
         machine   stack     stack     machine
    assembly address   address   data      code
      language ========  ========  ======== >>>>>>>>>>>>>>>>>>>>>>>>>>> ========= =============
    [00001307][00102190][00000000] 55         push
    ebp [00001308][00102190][00000000] 8bec >>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp [0000130a][0010218c][000012e7] >>>>>>>>>>>>>>>>>>>>>>>>>>> 68e7120000 push 000012e7 // >>>>>>>>>>>>>>>>>>>>>>>>>>> push P [0000130f][00102188][00001314] e8d3ffffff >>>>>>>>>>>>>>>>>>>>>>>>>>> call 000012e7
    // call P [000012e7][00102184][00102190] 55 push >>>>>>>>>>>>>>>>>>>>>>>>>>> ebp // enter executed P
    [000012e8][00102184][00102190] 8bec       mov >>>>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp [000012ea][00102184][00102190] 8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>>>   mov eax,[ebp+08]
    [000012ed][00102180][000012e7] 50         push
    eax      //
    push P [000012ee][00102180][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08] [000012f1][0010217c][000012e7] >>>>>>>>>>>>>>>>>>>>>>>>>>> 51 push ecx      // push P >>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f2][00102178][000012f7] e880feffff >>>>>>>>>>>>>>>>>>>>>>>>>>> call 00001177 // call H

    Begin Local Halt Decider Simulation   Execution >>>>>>>>>>>>>>>>>>>>>>>>>>> Trace Stored
    at:212244 [000012e7][00212230][00212234] 55 push >>>>>>>>>>>>>>>>>>>>>>>>>>> ebp // enter emulated P
    [000012e8][00212230][00212234] 8bec        mov
    ebp,esp [000012ea][00212230][00212234] 8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>>>    mov eax,[ebp+08]
    [000012ed][0021222c][000012e7] 50          push
    eax      //
    push P [000012ee][0021222c][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>>>   mov ecx,[ebp+08]
    [000012f1][00212228][000012e7] >>>>>>>>>>>>>>>>>>>>>>>>>>> 51 push ecx      // push P >>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f2][00212224][000012f7] e880feffff >>>>>>>>>>>>>>>>>>>>>>>>>>> call 00001177 // call H

    So, by what instruction reference manual is a >>>>>>>>>>>>>>>>>>>>>>>>>> call 00001177
    followedby the execution of the instruction at >>>>>>>>>>>>>>>>>>>>>>>>>> 000012e7.

    Your "CPU" is broken, or emulation incorrect. >>>>>>>>>>>>>>>>>>>>>>>>>>
    FAIL.
    [000012e7][0025cc58][0025cc5c] 55          push
    ebp      //
    enter emulated P
    [000012e8][0025cc58][0025cc5c] 8bec        mov
    ebp,esp [000012ea][0025cc58][0025cc5c] 8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>>>    mov eax,[ebp+08]
    [000012ed][0025cc54][000012e7] 50          push
    eax      //
    push P [000012ee][0025cc54][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>>>   mov ecx,[ebp+08]
    [000012f1][0025cc50][000012e7] >>>>>>>>>>>>>>>>>>>>>>>>>>> 51 push ecx      // push P >>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f2][0025cc4c][000012f7] e880feffff >>>>>>>>>>>>>>>>>>>>>>>>>>> call 00001177 // call H Local Halt Decider: >>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite Recursion
    Detected Simulation Stopped >>>>>>>>>>>>>>>>>>>>>>>>>>>
    It is completely obvious that when H(P,P) >>>>>>>>>>>>>>>>>>>>>>>>>>> correctly emulates
    its input that it must emulate the first seven >>>>>>>>>>>>>>>>>>>>>>>>>>> instructions of
    P. Because the seventh instruction of P repeats >>>>>>>>>>>>>>>>>>>>>>>>>>> this process we
    know with complete certainty that the correct >>>>>>>>>>>>>>>>>>>>>>>>>>> and complete
    emulation of P by H would never reach its final >>>>>>>>>>>>>>>>>>>>>>>>>>> “ret” instruction, thus never halts. >>>>>>>>>>>>>>>>>>>>>>>>>>
    Problem, the 7th intruction DOESN't "Just repeat >>>>>>>>>>>>>>>>>>>>>>>>>> the procedure",
    because that H always has the option to abort its >>>>>>>>>>>>>>>>>>>>>>>>>> simulation,
    just like this onne did, and return to its P and >>>>>>>>>>>>>>>>>>>>>>>>>> see it halt.
    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS >>>>>>>>>>>>>>>>>>>>>>>>> IS NO ACTUAL
    REBUTTAL AT ALL:

    The partial correct x86 emulation of the input to >>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) conclusively proves that the complete and >>>>>>>>>>>>>>>>>>>>>>>>> correct x86 emulation
    would never stop running.

    You SAY that, but you don't answer the actual >>>>>>>>>>>>>>>>>>>>>>>> questions about HOW.

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS >>>>>>>>>>>>>>>>>>>>>>> NO EVIDENCE
    WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE THAT >>>>>>>>>>>>>>>>>>>>>>> THE CORRECT
    PARTIAL EMULATION OF THE INPUT TO H(P,P) >>>>>>>>>>>>>>>>>>>>>>> CONCLUSIVELY PROVES THAT
    THE CORRECT AND COMPLETE X86 EMULATION OF THE INPUT >>>>>>>>>>>>>>>>>>>>>>> TO H(P,P)
    WOULD NEVER STOP RUNNING.

    It is completely obvious that when H(P,P) correctly >>>>>>>>>>>>>>>>>>>>>>> emulates its
    input that it must emulate the first seven >>>>>>>>>>>>>>>>>>>>>>> instructions of P.
    Because the seventh instruction of P repeats this >>>>>>>>>>>>>>>>>>>>>>> process we know
    with complete certainty that the correct and >>>>>>>>>>>>>>>>>>>>>>> complete emulation of
    P by H would never reach its final “ret” >>>>>>>>>>>>>>>>>>>>>>> instruction, thus never
    halts.

    If P should have halted (i.e. no infinite loop) then >>>>>>>>>>>>>>>>>>>>>> your simulation
    detector, S (not H), gets the answer wrong.  You S is >>>>>>>>>>>>>>>>>>>>>> NOT a halting
    decider.

    /Flibble

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS >>>>>>>>>>>>>>>>>>>>> NO ACTUAL
    REBUTTAL AT ALL.

    _P()
    [00001352](01)  55              push ebp >>>>>>>>>>>>>>>>>>>>> [00001353](02)  8bec            mov ebp,esp >>>>>>>>>>>>>>>>>>>>> [00001355](03)  8b4508          mov eax,[ebp+08]
    [00001358](01)  50              push eax      //
    push P
    [00001359](03)  8b4d08          mov ecx,[ebp+08]
    [0000135c](01)  51              push ecx      //
    push P
    [0000135d](05)  e840feffff      call 000011a2 // >>>>>>>>>>>>>>>>>>>>> call H
    [00001362](03)  83c408          add esp,+08 >>>>>>>>>>>>>>>>>>>>> [00001365](02)  85c0            test eax,eax >>>>>>>>>>>>>>>>>>>>> [00001367](02)  7402            jz 0000136b >>>>>>>>>>>>>>>>>>>>> [00001369](02)  ebfe            jmp 00001369 >>>>>>>>>>>>>>>>>>>>> [0000136b](01)  5d              pop ebp >>>>>>>>>>>>>>>>>>>>> [0000136c](01)  c3              ret >>>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]

    It is completely obvious that when H(P,P) correctly >>>>>>>>>>>>>>>>>>>>> emulates its
    input that it must emulate the first seven >>>>>>>>>>>>>>>>>>>>> instructions of P. Because
    the seventh instruction of P repeats this process we >>>>>>>>>>>>>>>>>>>>> know with
    complete certainty that the correct and complete >>>>>>>>>>>>>>>>>>>>> emulation of P by H
    would never reach its final “ret” instruction, thus >>>>>>>>>>>>>>>>>>>>> never halts.

    We are going around and around and around in circles. I >>>>>>>>>>>>>>>>>>>> will try again:

    If you replace the opcodes "EB FE" at 00001369 with the >>>>>>>>>>>>>>>>>>>> opcodes "90 90"
    then your H gets the answer wrong: P should have >>>>>>>>>>>>>>>>>>>> halted.

    /Flibble

    As I already said before this is merely your >>>>>>>>>>>>>>>>>>> cluelessness that when H(P,P) is invoked the correct x86 >>>>>>>>>>>>>>>>>>> emulation of the input to H(P,P) makes and code after >>>>>>>>>>>>>>>>>>> [0000135d] unreachable.

    Wrong, because when that H return the value 0, it will >>>>>>>>>>>>>>>>>> get there.
    Like I said people that are dumber than a box of rocks >>>>>>>>>>>>>>>>> won't be able to correctly understand this.

    When H(P,P) is invoked the correctly emulated input to >>>>>>>>>>>>>>>>> H(P,P) cannot possibly reach any instruction beyond >>>>>>>>>>>>>>>>> [0000135d].

    So, you are defining that you H(P,P) never returns because >>>>>>>>>>>>>>>> it is caught in the infinite rcursion.

    Thats fine, just says it can't be the correctly answering >>>>>>>>>>>>>>>> decider you claim it to be.

    I have corrected you on this too many times.

    How. You need to define what H(P,P) actually does.

    I have explained that too many times.

    To understand that H(P,P)==0 is correct we only need to know >>>>>>>>>>>>> that H performs a correct x86 emulation of its input and then >>>>>>>>>>>>> examine the execution trace.

    And a CORRECT emulation of the code will Halt if H(P,P) returns >>>>>>>>>>>> 0, which it can only do if it does not actually do a correct >>>>>>>>>>>> emulation

    The correctly emulated input to H(P,P) never gets past its >>>>>>>>>>> machine address [0000135d].


    Only if H actually doesn't return 0. Yes, H can't correctly >>>>>>>>>> return 0 if it correctly emulates its input, but you can't drop >>>>>>>>>> that requirement.

    void P(u32 x)
    {
        if (H(x, x))
          HERE: goto HERE;
        return;
    }

    int main()
    {
        Output("Input_Halts = ", H((u32)P, (u32)P));
    }

    When H returns 0 it does not returns 0 to P it returns 0 to
    main().

    But it also return 0 to the computation P(P), maybe not the copy >>>>>>>> that it is simulating, since it aborts that before it get to it, >>>>>>>
    Finally you are not stupid or deceptive.

    If H never returns a value to P then H is not a halting decider; if H >>>>>> returns a value of 0 to main() when P halts then H is not a halting >>>>>> decider.

    H is not a halting decider; H is a simulation detector, S.

    /Flibble


    In other words you are saying the infintely nested emulation only
    excutes for a few steps and then it stops on its own.


    No, the "infinitely nested emulation" halts when the first H(P,P)
    that P(P) called aborts it simulation.

    When I tell you that an input only halts when it reaches its final
    state and I tell you this many hundreds of times because you are a
    God damned liar you pretend that I never said this.


    Right, and when H(P,P) returns 0, the P that called it reaches its
    final state/the ret instrucion.

    YOU GOD DAMNED LIAR main() calls H(P,P) and H returns to main()

    void P(u32 x)
    {
      if (H(x, x))
        HERE: goto HERE;
      return;
    }

    int main()
    {
      Output("Input_Halts = ", H((u32)P, (u32)P));
    }




    Right, and P calls H which returns the 0 to P and P halts.

    If you deny the existance of the program P, then you invalidate your
    whole proof.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mr Flibble@21:1/5 to olcott on Fri Jun 10 12:11:02 2022
    XPost: comp.theory, sci.logic, sci.math

    On Thu, 9 Jun 2022 17:35:05 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 5:27 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:18:38 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 5:15 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:09:08 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 4:54 PM, Richard Damon wrote:
    On 6/9/22 5:29 PM, olcott wrote:
    On 6/9/2022 4:13 PM, Richard Damon wrote:

    On 6/9/22 5:00 PM, olcott wrote:
    On 6/9/2022 3:25 PM, Richard Damon wrote:
    On 6/9/22 4:13 PM, olcott wrote:
    On 6/9/2022 2:57 PM, Richard Damon wrote:
    On 6/9/22 3:52 PM, olcott wrote:
    On 6/9/2022 2:38 PM, Richard Damon wrote:

    On 6/9/22 3:26 PM, olcott wrote:
    On 6/9/2022 1:12 PM, Richard Damon wrote:
    On 6/9/22 1:55 PM, olcott wrote:
    On 6/9/2022 12:46 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:39:32 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 12:28 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 12:15:24 -0500
    olcott <NoOne@NoWhere.com> wrote:
    On 6/9/2022 12:06 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 6/9/22 12:54 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 11:34 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 11:47 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> void P(u32 x)
    {
         if (H(x, x))
           HERE: goto HERE; >>>>>>>>>>>>>>>>>>>>>>>>      return;
    }

    int main()
    {
         P(P);
    }

    _P()
    [000012e7](01)  55              push ebp
    [000012e8](02)  8bec            mov ebp,esp
    [000012ea](03)  8b4508          mov >>>>>>>>>>>>>>>>>>>>>>>> eax,[ebp+08] [000012ed](01)  50 >>>>>>>>>>>>>>>>>>>>>>>> push eax [000012ee](03)  8b4d08          mov
    ecx,[ebp+08] [000012f1](01)  51 >>>>>>>>>>>>>>>>>>>>>>>> push ecx [000012f2](05)  e880feffff      call >>>>>>>>>>>>>>>>>>>>>>>> 00001177 // call H [000012f7](03)  83c408 >>>>>>>>>>>>>>>>>>>>>>>>     add esp,+08 [000012fa](02)  85c0 >>>>>>>>>>>>>>>>>>>>>>>> test eax,eax [000012fc](02)  7402 >>>>>>>>>>>>>>>>>>>>>>>> jz 00001300 [000012fe](02)  ebfe >>>>>>>>>>>>>>>>>>>>>>>> jmp 000012fe [00001300](01)  5d >>>>>>>>>>>>>>>>>>>>>>>> pop ebp [00001301](01)  c3              ret
    Size in bytes:(0027) [00001301] >>>>>>>>>>>>>>>>>>>>>>>>
    _main()
    [00001307](01)  55              push ebp
    [00001308](02)  8bec            mov ebp,esp
    [0000130a](05)  68e7120000      push 000012e7 >>>>>>>>>>>>>>>>>>>>>>>> // push P [0000130f](05)  e8d3ffffff >>>>>>>>>>>>>>>>>>>>>>>> call 000012e7 // call P [00001314](03) >>>>>>>>>>>>>>>>>>>>>>>> 83c404 add esp,+04 [00001317](02)  33c0 >>>>>>>>>>>>>>>>>>>>>>>> xor eax,eax [00001319](01)  5d >>>>>>>>>>>>>>>>>>>>>>>> pop ebp [0000131a](01)  c3              ret
    Size in bytes:(0020) [0000131a] >>>>>>>>>>>>>>>>>>>>>>>>
        machine   stack     stack     machine
    assembly address   address   data      code >>>>>>>>>>>>>>>>>>>>>>>> language ========  ========  ======== >>>>>>>>>>>>>>>>>>>>>>>> ========= =============
    [00001307][00102190][00000000] 55 >>>>>>>>>>>>>>>>>>>>>>>> push ebp [00001308][00102190][00000000] 8bec >>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp [0000130a][0010218c][000012e7] >>>>>>>>>>>>>>>>>>>>>>>> 68e7120000 push 000012e7 //
    push P [0000130f][00102188][00001314] >>>>>>>>>>>>>>>>>>>>>>>> e8d3ffffff call 000012e7
    // call P [000012e7][00102184][00102190] 55 >>>>>>>>>>>>>>>>>>>>>>>> push ebp // enter executed P >>>>>>>>>>>>>>>>>>>>>>>> [000012e8][00102184][00102190] 8bec       mov >>>>>>>>>>>>>>>>>>>>>>>> ebp,esp [000012ea][00102184][00102190] 8b4508 >>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08]
    [000012ed][00102180][000012e7] 50 >>>>>>>>>>>>>>>>>>>>>>>> push eax      //
    push P [000012ee][00102180][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08]
    [000012f1][0010217c][000012e7] 51 push ecx >>>>>>>>>>>>>>>>>>>>>>>>    // push P [000012f2][00102178][000012f7] >>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H >>>>>>>>>>>>>>>>>>>>>>>>
    Begin Local Halt Decider Simulation >>>>>>>>>>>>>>>>>>>>>>>> Execution Trace Stored
    at:212244 [000012e7][00212230][00212234] 55 >>>>>>>>>>>>>>>>>>>>>>>> push ebp // enter emulated P >>>>>>>>>>>>>>>>>>>>>>>> [000012e8][00212230][00212234] 8bec >>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp [000012ea][00212230][00212234] >>>>>>>>>>>>>>>>>>>>>>>> 8b4508 mov eax,[ebp+08]
    [000012ed][0021222c][000012e7] 50 >>>>>>>>>>>>>>>>>>>>>>>> push eax      //
    push P [000012ee][0021222c][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08]
    [000012f1][00212228][000012e7] 51 push ecx >>>>>>>>>>>>>>>>>>>>>>>> // push P [000012f2][00212224][000012f7] >>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H >>>>>>>>>>>>>>>>>>>>>>>
    So, by what instruction reference manual is a >>>>>>>>>>>>>>>>>>>>>>> call 00001177
    followedby the execution of the instruction at >>>>>>>>>>>>>>>>>>>>>>> 000012e7.

    Your "CPU" is broken, or emulation incorrect. >>>>>>>>>>>>>>>>>>>>>>>
    FAIL.
    [000012e7][0025cc58][0025cc5c] 55 >>>>>>>>>>>>>>>>>>>>>>>> push ebp      //
    enter emulated P
    [000012e8][0025cc58][0025cc5c] 8bec >>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp [000012ea][0025cc58][0025cc5c] >>>>>>>>>>>>>>>>>>>>>>>> 8b4508 mov eax,[ebp+08]
    [000012ed][0025cc54][000012e7] 50 >>>>>>>>>>>>>>>>>>>>>>>> push eax      //
    push P [000012ee][0025cc54][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08]
    [000012f1][0025cc50][000012e7] 51 push ecx >>>>>>>>>>>>>>>>>>>>>>>> // push P [000012f2][0025cc4c][000012f7] >>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H Local Halt >>>>>>>>>>>>>>>>>>>>>>>> Decider: Infinite Recursion
    Detected Simulation Stopped

    It is completely obvious that when H(P,P) >>>>>>>>>>>>>>>>>>>>>>>> correctly emulates
    its input that it must emulate the first >>>>>>>>>>>>>>>>>>>>>>>> seven instructions of
    P. Because the seventh instruction of P >>>>>>>>>>>>>>>>>>>>>>>> repeats this process we
    know with complete certainty that the correct >>>>>>>>>>>>>>>>>>>>>>>> and complete
    emulation of P by H would never reach its >>>>>>>>>>>>>>>>>>>>>>>> final “ret” instruction, thus never halts. >>>>>>>>>>>>>>>>>>>>>>>
    Problem, the 7th intruction DOESN't "Just >>>>>>>>>>>>>>>>>>>>>>> repeat the procedure",
    because that H always has the option to abort >>>>>>>>>>>>>>>>>>>>>>> its simulation,
    just like this onne did, and return to its P >>>>>>>>>>>>>>>>>>>>>>> and see it halt.
    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND >>>>>>>>>>>>>>>>>>>>>> THIS IS NO ACTUAL
    REBUTTAL AT ALL:

    The partial correct x86 emulation of the input >>>>>>>>>>>>>>>>>>>>>> to H(P,P) conclusively proves that the >>>>>>>>>>>>>>>>>>>>>> complete and correct x86 emulation >>>>>>>>>>>>>>>>>>>>>> would never stop running.


    You SAY that, but you don't answer the actual >>>>>>>>>>>>>>>>>>>>> questions about HOW.

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS >>>>>>>>>>>>>>>>>>>> IS NO EVIDENCE
    WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE THAT >>>>>>>>>>>>>>>>>>>> THE CORRECT
    PARTIAL EMULATION OF THE INPUT TO H(P,P) >>>>>>>>>>>>>>>>>>>> CONCLUSIVELY PROVES THAT
    THE CORRECT AND COMPLETE X86 EMULATION OF THE >>>>>>>>>>>>>>>>>>>> INPUT TO H(P,P)
    WOULD NEVER STOP RUNNING.

    It is completely obvious that when H(P,P) >>>>>>>>>>>>>>>>>>>> correctly emulates its
    input that it must emulate the first seven >>>>>>>>>>>>>>>>>>>> instructions of P.
    Because the seventh instruction of P repeats this >>>>>>>>>>>>>>>>>>>> process we know
    with complete certainty that the correct and >>>>>>>>>>>>>>>>>>>> complete emulation of
    P by H would never reach its final “ret” >>>>>>>>>>>>>>>>>>>> instruction, thus never
    halts.

    If P should have halted (i.e. no infinite loop) >>>>>>>>>>>>>>>>>>> then your simulation
    detector, S (not H), gets the answer wrong.  You S >>>>>>>>>>>>>>>>>>> is NOT a halting
    decider.

    /Flibble

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS >>>>>>>>>>>>>>>>>> IS NO ACTUAL
    REBUTTAL AT ALL.

    _P()
    [00001352](01)  55              push ebp >>>>>>>>>>>>>>>>>> [00001353](02)  8bec            mov ebp,esp >>>>>>>>>>>>>>>>>> [00001355](03)  8b4508          mov eax,[ebp+08] >>>>>>>>>>>>>>>>>> [00001358](01)  50              push eax      //
    push P [00001359](03)  8b4d08          mov >>>>>>>>>>>>>>>>>> ecx,[ebp+08] [0000135c](01)  51              push
    ecx      // push P [0000135d](05)  e840feffff >>>>>>>>>>>>>>>>>> call 000011a2 // call H [00001362](03)  83c408 >>>>>>>>>>>>>>>>>>    add esp,+08 [00001365](02)  85c0
    test eax,eax [00001367](02)  7402            jz
    0000136b [00001369](02)  ebfe            jmp >>>>>>>>>>>>>>>>>> 00001369 [0000136b](01)  5d              pop ebp
    [0000136c](01)  c3              ret >>>>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]

    It is completely obvious that when H(P,P) correctly >>>>>>>>>>>>>>>>>> emulates its
    input that it must emulate the first seven >>>>>>>>>>>>>>>>>> instructions of P. Because
    the seventh instruction of P repeats this process >>>>>>>>>>>>>>>>>> we know with
    complete certainty that the correct and complete >>>>>>>>>>>>>>>>>> emulation of P by H
    would never reach its final “ret” instruction, thus >>>>>>>>>>>>>>>>>> never halts.

    We are going around and around and around in >>>>>>>>>>>>>>>>> circles. I will try again:

    If you replace the opcodes "EB FE" at 00001369 with >>>>>>>>>>>>>>>>> the opcodes "90 90"
    then your H gets the answer wrong: P should have >>>>>>>>>>>>>>>>> halted.

    /Flibble


    As I already said before this is merely your >>>>>>>>>>>>>>>> cluelessness that when H(P,P) is invoked the correct >>>>>>>>>>>>>>>> x86 emulation of the input to H(P,P) makes and code >>>>>>>>>>>>>>>> after [0000135d] unreachable.

    Wrong, because when that H return the value 0, it will >>>>>>>>>>>>>>> get there.
    Like I said people that are dumber than a box of rocks >>>>>>>>>>>>>> won't be able to correctly understand this.

    When H(P,P) is invoked the correctly emulated input to >>>>>>>>>>>>>> H(P,P) cannot possibly reach any instruction beyond >>>>>>>>>>>>>> [0000135d].

    So, you are defining that you H(P,P) never returns >>>>>>>>>>>>> because it is caught in the infinite rcursion.

    Thats fine, just says it can't be the correctly
    answering decider you claim it to be.

    I have corrected you on this too many times.


    How. You need to define what H(P,P) actually does.

    I have explained that too many times.

    To understand that H(P,P)==0 is correct we only need to
    know that H performs a correct x86 emulation of its input >>>>>>>>>> and then examine the execution trace.

    And a CORRECT emulation of the code will Halt if H(P,P)
    returns 0, which it can only do if it does not actually do a >>>>>>>>> correct emulation

    The correctly emulated input to H(P,P) never gets past its
    machine address [0000135d].



    Only if H actually doesn't return 0. Yes, H can't correctly
    return 0 if it correctly emulates its input, but you can't
    drop that requirement.

    void P(u32 x)
    {
       if (H(x, x))
         HERE: goto HERE;
       return;
    }

    int main()
    {
       Output("Input_Halts = ", H((u32)P, (u32)P));
    }

    When H returns 0 it does not returns 0 to P it returns 0 to
    main().

    But it also return 0 to the computation P(P), maybe not the copy
    that it is simulating, since it aborts that before it get to
    it,

    Finally you are not stupid or deceptive.

    If H never returns a value to P then H is not a halting decider;
    if H returns a value of 0 to main() when P halts then H is not a
    halting decider.

    H is not a halting decider; H is a simulation detector, S.

    /Flibble


    In other words you are saying the infintely nested emulation only
    excutes for a few steps and then it stops on its own.

    I am saying that your H is not a halting decider; I am saying that
    your H is just a simulation detector, S.

    /Flibble


    You are saying that you simply "don't believe in" simulating halt
    deciders.

    You haven't got a simulating halt decider, what you have got is a
    simulation detector.

    /Flibble

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Mr Flibble on Fri Jun 10 08:05:57 2022
    XPost: comp.theory, sci.logic, sci.math

    On 6/10/2022 6:11 AM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:35:05 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 5:27 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:18:38 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 5:15 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:09:08 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 4:54 PM, Richard Damon wrote:
    On 6/9/22 5:29 PM, olcott wrote:
    On 6/9/2022 4:13 PM, Richard Damon wrote:

    On 6/9/22 5:00 PM, olcott wrote:
    On 6/9/2022 3:25 PM, Richard Damon wrote:
    On 6/9/22 4:13 PM, olcott wrote:
    On 6/9/2022 2:57 PM, Richard Damon wrote:
    On 6/9/22 3:52 PM, olcott wrote:
    On 6/9/2022 2:38 PM, Richard Damon wrote:

    On 6/9/22 3:26 PM, olcott wrote:
    On 6/9/2022 1:12 PM, Richard Damon wrote:
    On 6/9/22 1:55 PM, olcott wrote:
    On 6/9/2022 12:46 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 12:39:32 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 12:28 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 12:15:24 -0500
    olcott <NoOne@NoWhere.com> wrote:
    On 6/9/2022 12:06 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 12:54 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 11:34 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 11:47 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> void P(u32 x)
    {
         if (H(x, x))
           HERE: goto HERE; >>>>>>>>>>>>>>>>>>>>>>>>>>      return;
    }

    int main()
    {
         P(P);
    }

    _P()
    [000012e7](01)  55              push ebp
    [000012e8](02)  8bec            mov ebp,esp
    [000012ea](03)  8b4508          mov >>>>>>>>>>>>>>>>>>>>>>>>>> eax,[ebp+08] [000012ed](01)  50 >>>>>>>>>>>>>>>>>>>>>>>>>> push eax [000012ee](03)  8b4d08          mov
    ecx,[ebp+08] [000012f1](01)  51 >>>>>>>>>>>>>>>>>>>>>>>>>> push ecx [000012f2](05)  e880feffff      call >>>>>>>>>>>>>>>>>>>>>>>>>> 00001177 // call H [000012f7](03)  83c408 >>>>>>>>>>>>>>>>>>>>>>>>>>     add esp,+08 [000012fa](02)  85c0 >>>>>>>>>>>>>>>>>>>>>>>>>> test eax,eax [000012fc](02)  7402 >>>>>>>>>>>>>>>>>>>>>>>>>> jz 00001300 [000012fe](02)  ebfe >>>>>>>>>>>>>>>>>>>>>>>>>> jmp 000012fe [00001300](01)  5d >>>>>>>>>>>>>>>>>>>>>>>>>> pop ebp [00001301](01)  c3              ret
    Size in bytes:(0027) [00001301] >>>>>>>>>>>>>>>>>>>>>>>>>>
    _main()
    [00001307](01)  55              push ebp
    [00001308](02)  8bec            mov ebp,esp
    [0000130a](05)  68e7120000      push 000012e7 >>>>>>>>>>>>>>>>>>>>>>>>>> // push P [0000130f](05)  e8d3ffffff >>>>>>>>>>>>>>>>>>>>>>>>>> call 000012e7 // call P [00001314](03) >>>>>>>>>>>>>>>>>>>>>>>>>> 83c404 add esp,+04 [00001317](02)  33c0 >>>>>>>>>>>>>>>>>>>>>>>>>> xor eax,eax [00001319](01)  5d >>>>>>>>>>>>>>>>>>>>>>>>>> pop ebp [0000131a](01)  c3              ret
    Size in bytes:(0020) [0000131a] >>>>>>>>>>>>>>>>>>>>>>>>>>
        machine   stack     stack     machine
    assembly address   address   data      code >>>>>>>>>>>>>>>>>>>>>>>>>> language ========  ========  ======== >>>>>>>>>>>>>>>>>>>>>>>>>> ========= =============
    [00001307][00102190][00000000] 55 >>>>>>>>>>>>>>>>>>>>>>>>>> push ebp [00001308][00102190][00000000] 8bec >>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp [0000130a][0010218c][000012e7] >>>>>>>>>>>>>>>>>>>>>>>>>> 68e7120000 push 000012e7 // >>>>>>>>>>>>>>>>>>>>>>>>>> push P [0000130f][00102188][00001314] >>>>>>>>>>>>>>>>>>>>>>>>>> e8d3ffffff call 000012e7
    // call P [000012e7][00102184][00102190] 55 >>>>>>>>>>>>>>>>>>>>>>>>>> push ebp // enter executed P >>>>>>>>>>>>>>>>>>>>>>>>>> [000012e8][00102184][00102190] 8bec       mov >>>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp [000012ea][00102184][00102190] 8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08]
    [000012ed][00102180][000012e7] 50 >>>>>>>>>>>>>>>>>>>>>>>>>> push eax      //
    push P [000012ee][00102180][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08]
    [000012f1][0010217c][000012e7] 51 push ecx >>>>>>>>>>>>>>>>>>>>>>>>>>    // push P [000012f2][00102178][000012f7] >>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H >>>>>>>>>>>>>>>>>>>>>>>>>>
    Begin Local Halt Decider Simulation >>>>>>>>>>>>>>>>>>>>>>>>>> Execution Trace Stored
    at:212244 [000012e7][00212230][00212234] 55 >>>>>>>>>>>>>>>>>>>>>>>>>> push ebp // enter emulated P >>>>>>>>>>>>>>>>>>>>>>>>>> [000012e8][00212230][00212234] 8bec >>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp [000012ea][00212230][00212234] >>>>>>>>>>>>>>>>>>>>>>>>>> 8b4508 mov eax,[ebp+08]
    [000012ed][0021222c][000012e7] 50 >>>>>>>>>>>>>>>>>>>>>>>>>> push eax      //
    push P [000012ee][0021222c][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08]
    [000012f1][00212228][000012e7] 51 push ecx >>>>>>>>>>>>>>>>>>>>>>>>>> // push P [000012f2][00212224][000012f7] >>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H >>>>>>>>>>>>>>>>>>>>>>>>>
    So, by what instruction reference manual is a >>>>>>>>>>>>>>>>>>>>>>>>> call 00001177
    followedby the execution of the instruction at >>>>>>>>>>>>>>>>>>>>>>>>> 000012e7.

    Your "CPU" is broken, or emulation incorrect. >>>>>>>>>>>>>>>>>>>>>>>>>
    FAIL.
    [000012e7][0025cc58][0025cc5c] 55 >>>>>>>>>>>>>>>>>>>>>>>>>> push ebp      //
    enter emulated P
    [000012e8][0025cc58][0025cc5c] 8bec >>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp [000012ea][0025cc58][0025cc5c] >>>>>>>>>>>>>>>>>>>>>>>>>> 8b4508 mov eax,[ebp+08]
    [000012ed][0025cc54][000012e7] 50 >>>>>>>>>>>>>>>>>>>>>>>>>> push eax      //
    push P [000012ee][0025cc54][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08]
    [000012f1][0025cc50][000012e7] 51 push ecx >>>>>>>>>>>>>>>>>>>>>>>>>> // push P [000012f2][0025cc4c][000012f7] >>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H Local Halt >>>>>>>>>>>>>>>>>>>>>>>>>> Decider: Infinite Recursion >>>>>>>>>>>>>>>>>>>>>>>>>> Detected Simulation Stopped >>>>>>>>>>>>>>>>>>>>>>>>>>
    It is completely obvious that when H(P,P) >>>>>>>>>>>>>>>>>>>>>>>>>> correctly emulates
    its input that it must emulate the first >>>>>>>>>>>>>>>>>>>>>>>>>> seven instructions of
    P. Because the seventh instruction of P >>>>>>>>>>>>>>>>>>>>>>>>>> repeats this process we
    know with complete certainty that the correct >>>>>>>>>>>>>>>>>>>>>>>>>> and complete
    emulation of P by H would never reach its >>>>>>>>>>>>>>>>>>>>>>>>>> final “ret” instruction, thus never halts. >>>>>>>>>>>>>>>>>>>>>>>>>
    Problem, the 7th intruction DOESN't "Just >>>>>>>>>>>>>>>>>>>>>>>>> repeat the procedure",
    because that H always has the option to abort >>>>>>>>>>>>>>>>>>>>>>>>> its simulation,
    just like this onne did, and return to its P >>>>>>>>>>>>>>>>>>>>>>>>> and see it halt.
    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND >>>>>>>>>>>>>>>>>>>>>>>> THIS IS NO ACTUAL
    REBUTTAL AT ALL:

    The partial correct x86 emulation of the input >>>>>>>>>>>>>>>>>>>>>>>> to H(P,P) conclusively proves that the >>>>>>>>>>>>>>>>>>>>>>>> complete and correct x86 emulation >>>>>>>>>>>>>>>>>>>>>>>> would never stop running.


    You SAY that, but you don't answer the actual >>>>>>>>>>>>>>>>>>>>>>> questions about HOW.

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS >>>>>>>>>>>>>>>>>>>>>> IS NO EVIDENCE
    WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE THAT >>>>>>>>>>>>>>>>>>>>>> THE CORRECT
    PARTIAL EMULATION OF THE INPUT TO H(P,P) >>>>>>>>>>>>>>>>>>>>>> CONCLUSIVELY PROVES THAT
    THE CORRECT AND COMPLETE X86 EMULATION OF THE >>>>>>>>>>>>>>>>>>>>>> INPUT TO H(P,P)
    WOULD NEVER STOP RUNNING.

    It is completely obvious that when H(P,P) >>>>>>>>>>>>>>>>>>>>>> correctly emulates its
    input that it must emulate the first seven >>>>>>>>>>>>>>>>>>>>>> instructions of P.
    Because the seventh instruction of P repeats this >>>>>>>>>>>>>>>>>>>>>> process we know
    with complete certainty that the correct and >>>>>>>>>>>>>>>>>>>>>> complete emulation of
    P by H would never reach its final “ret” >>>>>>>>>>>>>>>>>>>>>> instruction, thus never
    halts.

    If P should have halted (i.e. no infinite loop) >>>>>>>>>>>>>>>>>>>>> then your simulation
    detector, S (not H), gets the answer wrong.  You S >>>>>>>>>>>>>>>>>>>>> is NOT a halting
    decider.

    /Flibble

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS >>>>>>>>>>>>>>>>>>>> IS NO ACTUAL
    REBUTTAL AT ALL.

    _P()
    [00001352](01)  55              push ebp >>>>>>>>>>>>>>>>>>>> [00001353](02)  8bec            mov ebp,esp >>>>>>>>>>>>>>>>>>>> [00001355](03)  8b4508          mov eax,[ebp+08] >>>>>>>>>>>>>>>>>>>> [00001358](01)  50              push eax      //
    push P [00001359](03)  8b4d08          mov >>>>>>>>>>>>>>>>>>>> ecx,[ebp+08] [0000135c](01)  51              push
    ecx      // push P [0000135d](05)  e840feffff >>>>>>>>>>>>>>>>>>>> call 000011a2 // call H [00001362](03)  83c408 >>>>>>>>>>>>>>>>>>>>    add esp,+08 [00001365](02)  85c0 >>>>>>>>>>>>>>>>>>>> test eax,eax [00001367](02)  7402            jz
    0000136b [00001369](02)  ebfe            jmp >>>>>>>>>>>>>>>>>>>> 00001369 [0000136b](01)  5d              pop ebp
    [0000136c](01)  c3              ret >>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]

    It is completely obvious that when H(P,P) correctly >>>>>>>>>>>>>>>>>>>> emulates its
    input that it must emulate the first seven >>>>>>>>>>>>>>>>>>>> instructions of P. Because
    the seventh instruction of P repeats this process >>>>>>>>>>>>>>>>>>>> we know with
    complete certainty that the correct and complete >>>>>>>>>>>>>>>>>>>> emulation of P by H
    would never reach its final “ret” instruction, thus >>>>>>>>>>>>>>>>>>>> never halts.

    We are going around and around and around in >>>>>>>>>>>>>>>>>>> circles. I will try again:

    If you replace the opcodes "EB FE" at 00001369 with >>>>>>>>>>>>>>>>>>> the opcodes "90 90"
    then your H gets the answer wrong: P should have >>>>>>>>>>>>>>>>>>> halted.

    /Flibble


    As I already said before this is merely your >>>>>>>>>>>>>>>>>> cluelessness that when H(P,P) is invoked the correct >>>>>>>>>>>>>>>>>> x86 emulation of the input to H(P,P) makes and code >>>>>>>>>>>>>>>>>> after [0000135d] unreachable.

    Wrong, because when that H return the value 0, it will >>>>>>>>>>>>>>>>> get there.
    Like I said people that are dumber than a box of rocks >>>>>>>>>>>>>>>> won't be able to correctly understand this.

    When H(P,P) is invoked the correctly emulated input to >>>>>>>>>>>>>>>> H(P,P) cannot possibly reach any instruction beyond >>>>>>>>>>>>>>>> [0000135d].

    So, you are defining that you H(P,P) never returns >>>>>>>>>>>>>>> because it is caught in the infinite rcursion.

    Thats fine, just says it can't be the correctly
    answering decider you claim it to be.

    I have corrected you on this too many times.


    How. You need to define what H(P,P) actually does.

    I have explained that too many times.

    To understand that H(P,P)==0 is correct we only need to >>>>>>>>>>>> know that H performs a correct x86 emulation of its input >>>>>>>>>>>> and then examine the execution trace.

    And a CORRECT emulation of the code will Halt if H(P,P)
    returns 0, which it can only do if it does not actually do a >>>>>>>>>>> correct emulation

    The correctly emulated input to H(P,P) never gets past its >>>>>>>>>> machine address [0000135d].



    Only if H actually doesn't return 0. Yes, H can't correctly
    return 0 if it correctly emulates its input, but you can't
    drop that requirement.

    void P(u32 x)
    {
       if (H(x, x))
         HERE: goto HERE;
       return;
    }

    int main()
    {
       Output("Input_Halts = ", H((u32)P, (u32)P));
    }

    When H returns 0 it does not returns 0 to P it returns 0 to
    main().

    But it also return 0 to the computation P(P), maybe not the copy >>>>>>> that it is simulating, since it aborts that before it get to
    it,

    Finally you are not stupid or deceptive.

    If H never returns a value to P then H is not a halting decider;
    if H returns a value of 0 to main() when P halts then H is not a
    halting decider.

    H is not a halting decider; H is a simulation detector, S.

    /Flibble


    In other words you are saying the infintely nested emulation only
    excutes for a few steps and then it stops on its own.

    I am saying that your H is not a halting decider; I am saying that
    your H is just a simulation detector, S.

    /Flibble


    You are saying that you simply "don't believe in" simulating halt
    deciders.

    You haven't got a simulating halt decider, what you have got is a
    simulation detector.

    /Flibble


    It is an easily verified fact that H does correctly decide the halt
    status of its input.

    void Infinite_Loop()
    {
    HERE: goto HERE;
    }

    int main()
    {
    Output("Input_Halts = ", H0(Infinite_Loop));
    }

    _Infinite_Loop()
    [00001342](01) 55 push ebp
    [00001343](02) 8bec mov ebp,esp
    [00001345](02) ebfe jmp 00001345
    [00001347](01) 5d pop ebp
    [00001348](01) c3 ret
    Size in bytes:(0007) [00001348]

    _main()
    [00001372](01) 55 push ebp
    [00001373](02) 8bec mov ebp,esp
    [00001375](05) 6842130000 push 00001342
    [0000137a](05) e833fdffff call 000010b2
    [0000137f](03) 83c404 add esp,+04
    [00001382](01) 50 push eax
    [00001383](05) 6823040000 push 00000423
    [00001388](05) e8e5f0ffff call 00000472
    [0000138d](03) 83c408 add esp,+08
    [00001390](02) 33c0 xor eax,eax
    [00001392](01) 5d pop ebp
    [00001393](01) c3 ret
    Size in bytes:(0034) [00001393]

    machine stack stack machine assembly
    address address data code language
    ======== ======== ======== ========= ============= [00001372][0010228f][00000000] 55 push ebp [00001373][0010228f][00000000] 8bec mov ebp,esp [00001375][0010228b][00001342] 6842130000 push 00001342 // push
    _Infinite_Loop
    [0000137a][00102287][0000137f] e833fdffff call 000010b2 // call H0

    Begin Local Halt Decider Simulation Execution Trace Stored at:212343 [00001342][00212333][00212337] 55 push ebp [00001343][00212333][00212337] 8bec mov ebp,esp [00001345][00212333][00212337] ebfe jmp 00001345 [00001345][00212333][00212337] ebfe jmp 00001345
    Local Halt Decider: Infinite Loop Detected Simulation Stopped

    [0000137f][0010228f][00000000] 83c404 add esp,+04 [00001382][0010228b][00000000] 50 push eax [00001383][00102287][00000423] 6823040000 push 00000423 [00001388][00102287][00000423] e8e5f0ffff call 00000472
    Input_Halts = 0
    [0000138d][0010228f][00000000] 83c408 add esp,+08 [00001390][0010228f][00000000] 33c0 xor eax,eax [00001392][00102293][00100000] 5d pop ebp [00001393][00102297][00000004] c3 ret
    Number of Instructions Executed(680)

    int Sum(int X, int Y)
    {
    return X + Y;
    }

    int main()
    {
    Output("Input_Halts = ", H2(Sum, 3, 4));
    }

    _Sum()
    [000012b6](01) 55 push ebp
    [000012b7](02) 8bec mov ebp,esp
    [000012b9](03) 8b4508 mov eax,[ebp+08]
    [000012bc](03) 03450c add eax,[ebp+0c]
    [000012bf](01) 5d pop ebp
    [000012c0](01) c3 ret
    Size in bytes:(0011) [000012c0]

    _main()
    [00001316](01) 55 push ebp
    [00001317](02) 8bec mov ebp,esp
    [00001319](02) 6a04 push +04
    [0000131b](02) 6a03 push +03
    [0000131d](05) 68b6120000 push 000012b6
    [00001322](05) e85ffaffff call 00000d86
    [00001327](03) 83c40c add esp,+0c
    [0000132a](01) 50 push eax
    [0000132b](05) 6807040000 push 00000407
    [00001330](05) e821f1ffff call 00000456
    [00001335](03) 83c408 add esp,+08
    [00001338](02) 33c0 xor eax,eax
    [0000133a](01) 5d pop ebp
    [0000133b](01) c3 ret
    Size in bytes:(0038) [0000133b]

    machine stack stack machine assembly
    address address data code language
    ======== ======== ======== ========= ============= ...[00001316][001021d7][00000000] 55 push ebp ...[00001317][001021d7][00000000] 8bec mov ebp,esp ...[00001319][001021d3][00000004] 6a04 push +04 ...[0000131b][001021cf][00000003] 6a03 push +03 ...[0000131d][001021cb][000012b6] 68b6120000 push 000012b6 ...[00001322][001021c7][00001327] e85ffaffff call 00000d86

    Begin Local Halt Decider Simulation Execution Trace Stored at:21228b ...[000012b6][00212273][00212277] 55 push ebp ...[000012b7][00212273][00212277] 8bec mov ebp,esp ...[000012b9][00212273][00212277] 8b4508 mov eax,[ebp+08] ...[000012bc][00212273][00212277] 03450c add eax,[ebp+0c] ...[000012bf][00212277][00000e54] 5d pop ebp ...[000012c0][0021227b][00000003] c3 ret ...[00001327][001021d7][00000000] 83c40c add esp,+0c ...[0000132a][001021d3][00000001] 50 push eax ...[0000132b][001021cf][00000407] 6807040000 push 00000407 ---[00001330][001021cf][00000407] e821f1ffff call 00000456
    Input_Halts = 1
    ...[00001335][001021d7][00000000] 83c408 add esp,+08 ...[00001338][001021d7][00000000] 33c0 xor eax,eax ...[0000133a][001021db][00100000] 5d pop ebp ...[0000133b][001021df][00000004] c3 ret
    Number of Instructions Executed(660)



    --
    Copyright 2022 Pete Olcott

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

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mr Flibble@21:1/5 to olcott on Fri Jun 10 14:29:59 2022
    XPost: comp.theory, sci.logic, sci.math

    On Fri, 10 Jun 2022 08:27:28 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/10/2022 8:23 AM, Mr Flibble wrote:
    On Fri, 10 Jun 2022 08:05:57 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/10/2022 6:11 AM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:35:05 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 5:27 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:18:38 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 5:15 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:09:08 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 4:54 PM, Richard Damon wrote:
    On 6/9/22 5:29 PM, olcott wrote:
    On 6/9/2022 4:13 PM, Richard Damon wrote:

    On 6/9/22 5:00 PM, olcott wrote:
    On 6/9/2022 3:25 PM, Richard Damon wrote:
    On 6/9/22 4:13 PM, olcott wrote:
    On 6/9/2022 2:57 PM, Richard Damon wrote:
    On 6/9/22 3:52 PM, olcott wrote:
    On 6/9/2022 2:38 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>
    On 6/9/22 3:26 PM, olcott wrote:
    On 6/9/2022 1:12 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 6/9/22 1:55 PM, olcott wrote:
    On 6/9/2022 12:46 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 12:39:32 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 12:28 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 12:15:24 -0500 >>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 12:06 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 12:54 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 11:34 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>
    On 6/9/22 11:47 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> void P(u32 x)
    {
         if (H(x, x)) >>>>>>>>>>>>>>>>>>>>>>>>>>>>        HERE: goto HERE; >>>>>>>>>>>>>>>>>>>>>>>>>>>>      return;
    }

    int main()
    {
         P(P);
    }

    _P()
    [000012e7](01)  55              push ebp
    [000012e8](02)  8bec            mov >>>>>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp [000012ea](03)  8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08] [000012ed](01)  50 >>>>>>>>>>>>>>>>>>>>>>>>>>>> push eax [000012ee](03)  8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08] [000012f1](01)  51 >>>>>>>>>>>>>>>>>>>>>>>>>>>> push ecx [000012f2](05)  e880feffff >>>>>>>>>>>>>>>>>>>>>>>>>>>> call 00001177 // call H [000012f7](03) >>>>>>>>>>>>>>>>>>>>>>>>>>>> 83c408 add esp,+08 [000012fa](02)  85c0 >>>>>>>>>>>>>>>>>>>>>>>>>>>> test eax,eax [000012fc](02)  7402 >>>>>>>>>>>>>>>>>>>>>>>>>>>> jz 00001300 [000012fe](02)  ebfe >>>>>>>>>>>>>>>>>>>>>>>>>>>> jmp 000012fe [00001300](01)  5d >>>>>>>>>>>>>>>>>>>>>>>>>>>> pop ebp [00001301](01)  c3 >>>>>>>>>>>>>>>>>>>>>>>>>>>> ret Size in bytes:(0027) [00001301] >>>>>>>>>>>>>>>>>>>>>>>>>>>>
    _main()
    [00001307](01)  55              push ebp
    [00001308](02)  8bec            mov >>>>>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp [0000130a](05)  68e7120000 >>>>>>>>>>>>>>>>>>>>>>>>>>>> push 000012e7 // push P [0000130f](05) >>>>>>>>>>>>>>>>>>>>>>>>>>>> e8d3ffffff call 000012e7 // call P >>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001314](03) 83c404 add esp,+04 >>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001317](02)  33c0 xor eax,eax >>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001319](01)  5d pop ebp [0000131a](01) >>>>>>>>>>>>>>>>>>>>>>>>>>>> c3              ret Size in bytes:(0020)
    [0000131a]

        machine   stack     stack >>>>>>>>>>>>>>>>>>>>>>>>>>>> machine assembly address   address   data >>>>>>>>>>>>>>>>>>>>>>>>>>>>     code language ========  ======== >>>>>>>>>>>>>>>>>>>>>>>>>>>> ======== ========= ============= >>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001307][00102190][00000000] 55 >>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp [00001308][00102190][00000000] >>>>>>>>>>>>>>>>>>>>>>>>>>>> 8bec mov ebp,esp
    [0000130a][0010218c][000012e7] 68e7120000 >>>>>>>>>>>>>>>>>>>>>>>>>>>> push 000012e7 // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000130f][00102188][00001314] e8d3ffffff >>>>>>>>>>>>>>>>>>>>>>>>>>>> call 000012e7 // call P >>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e7][00102184][00102190] 55 push >>>>>>>>>>>>>>>>>>>>>>>>>>>> ebp // enter executed P >>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e8][00102184][00102190] 8bec >>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp
    [000012ea][00102184][00102190] 8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08]
    [000012ed][00102180][000012e7] 50 push >>>>>>>>>>>>>>>>>>>>>>>>>>>> eax // push P
    [000012ee][00102180][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08]
    [000012f1][0010217c][000012e7] 51 push >>>>>>>>>>>>>>>>>>>>>>>>>>>> ecx // push P
    [000012f2][00102178][000012f7] >>>>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H >>>>>>>>>>>>>>>>>>>>>>>>>>>>
    Begin Local Halt Decider Simulation >>>>>>>>>>>>>>>>>>>>>>>>>>>> Execution Trace Stored >>>>>>>>>>>>>>>>>>>>>>>>>>>> at:212244 [000012e7][00212230][00212234] >>>>>>>>>>>>>>>>>>>>>>>>>>>> 55 push ebp // enter emulated P >>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e8][00212230][00212234] 8bec >>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp
    [000012ea][00212230][00212234] 8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08]
    [000012ed][0021222c][000012e7] 50 push >>>>>>>>>>>>>>>>>>>>>>>>>>>> eax      // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ee][0021222c][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08]
    [000012f1][00212228][000012e7] 51 push >>>>>>>>>>>>>>>>>>>>>>>>>>>> ecx // push P
    [000012f2][00212224][000012f7] >>>>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H >>>>>>>>>>>>>>>>>>>>>>>>>>>
    So, by what instruction reference manual >>>>>>>>>>>>>>>>>>>>>>>>>>> is a call 00001177
    followedby the execution of the >>>>>>>>>>>>>>>>>>>>>>>>>>> instruction at 000012e7. >>>>>>>>>>>>>>>>>>>>>>>>>>>
    Your "CPU" is broken, or emulation >>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect.

    FAIL.
    [000012e7][0025cc58][0025cc5c] 55 >>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp      // >>>>>>>>>>>>>>>>>>>>>>>>>>>> enter emulated P
    [000012e8][0025cc58][0025cc5c] 8bec >>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp
    [000012ea][0025cc58][0025cc5c] 8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08]
    [000012ed][0025cc54][000012e7] 50 push >>>>>>>>>>>>>>>>>>>>>>>>>>>> eax      // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ee][0025cc54][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08]
    [000012f1][0025cc50][000012e7] 51 push >>>>>>>>>>>>>>>>>>>>>>>>>>>> ecx // push P
    [000012f2][0025cc4c][000012f7] >>>>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H Local >>>>>>>>>>>>>>>>>>>>>>>>>>>> Halt Decider: Infinite Recursion >>>>>>>>>>>>>>>>>>>>>>>>>>>> Detected Simulation Stopped >>>>>>>>>>>>>>>>>>>>>>>>>>>>
    It is completely obvious that when H(P,P) >>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly emulates
    its input that it must emulate the first >>>>>>>>>>>>>>>>>>>>>>>>>>>> seven instructions of >>>>>>>>>>>>>>>>>>>>>>>>>>>> P. Because the seventh instruction of P >>>>>>>>>>>>>>>>>>>>>>>>>>>> repeats this process we >>>>>>>>>>>>>>>>>>>>>>>>>>>> know with complete certainty that the >>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete >>>>>>>>>>>>>>>>>>>>>>>>>>>> emulation of P by H would never reach its >>>>>>>>>>>>>>>>>>>>>>>>>>>> final “ret” instruction, thus never >>>>>>>>>>>>>>>>>>>>>>>>>>>> halts.

    Problem, the 7th intruction DOESN't "Just >>>>>>>>>>>>>>>>>>>>>>>>>>> repeat the procedure", >>>>>>>>>>>>>>>>>>>>>>>>>>> because that H always has the option to >>>>>>>>>>>>>>>>>>>>>>>>>>> abort its simulation,
    just like this onne did, and return to >>>>>>>>>>>>>>>>>>>>>>>>>>> its P and see it halt. >>>>>>>>>>>>>>>>>>>>>>>>>> THAT YOU ARE SIMPLY TOO STUPID TO >>>>>>>>>>>>>>>>>>>>>>>>>> UNDERSTAND THIS IS NO ACTUAL >>>>>>>>>>>>>>>>>>>>>>>>>> REBUTTAL AT ALL:

    The partial correct x86 emulation of the >>>>>>>>>>>>>>>>>>>>>>>>>> input to H(P,P) conclusively proves that >>>>>>>>>>>>>>>>>>>>>>>>>> the complete and correct x86 emulation >>>>>>>>>>>>>>>>>>>>>>>>>> would never stop running. >>>>>>>>>>>>>>>>>>>>>>>>>>

    You SAY that, but you don't answer the >>>>>>>>>>>>>>>>>>>>>>>>> actual questions about HOW. >>>>>>>>>>>>>>>>>>>>>>>>
    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND >>>>>>>>>>>>>>>>>>>>>>>> THIS IS NO EVIDENCE
    WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE >>>>>>>>>>>>>>>>>>>>>>>> THAT THE CORRECT
    PARTIAL EMULATION OF THE INPUT TO H(P,P) >>>>>>>>>>>>>>>>>>>>>>>> CONCLUSIVELY PROVES THAT
    THE CORRECT AND COMPLETE X86 EMULATION OF THE >>>>>>>>>>>>>>>>>>>>>>>> INPUT TO H(P,P)
    WOULD NEVER STOP RUNNING.

    It is completely obvious that when H(P,P) >>>>>>>>>>>>>>>>>>>>>>>> correctly emulates its
    input that it must emulate the first seven >>>>>>>>>>>>>>>>>>>>>>>> instructions of P.
    Because the seventh instruction of P repeats >>>>>>>>>>>>>>>>>>>>>>>> this process we know
    with complete certainty that the correct and >>>>>>>>>>>>>>>>>>>>>>>> complete emulation of
    P by H would never reach its final “ret” >>>>>>>>>>>>>>>>>>>>>>>> instruction, thus never
    halts.

    If P should have halted (i.e. no infinite >>>>>>>>>>>>>>>>>>>>>>> loop) then your simulation
    detector, S (not H), gets the answer wrong. >>>>>>>>>>>>>>>>>>>>>>> You S is NOT a halting
    decider.

    /Flibble

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND >>>>>>>>>>>>>>>>>>>>>> THIS IS NO ACTUAL
    REBUTTAL AT ALL.

    _P()
    [00001352](01)  55              push ebp >>>>>>>>>>>>>>>>>>>>>> [00001353](02)  8bec            mov ebp,esp
    [00001355](03)  8b4508          mov >>>>>>>>>>>>>>>>>>>>>> eax,[ebp+08] [00001358](01)  50 >>>>>>>>>>>>>>>>>>>>>> push eax      // push P [00001359](03)  8b4d08 >>>>>>>>>>>>>>>>>>>>>>          mov ecx,[ebp+08] [0000135c](01)  51 >>>>>>>>>>>>>>>>>>>>>>            push ecx      // push P >>>>>>>>>>>>>>>>>>>>>> [0000135d](05)  e840feffff call 000011a2 // >>>>>>>>>>>>>>>>>>>>>> call H [00001362](03)  83c408 add esp,+08 >>>>>>>>>>>>>>>>>>>>>> [00001365](02)  85c0 test eax,eax >>>>>>>>>>>>>>>>>>>>>> [00001367](02)  7402            jz 0000136b
    [00001369](02)  ebfe            jmp 00001369
    [0000136b](01)  5d              pop ebp >>>>>>>>>>>>>>>>>>>>>> [0000136c](01)  c3              ret Size in
    bytes:(0027) [0000136c]

    It is completely obvious that when H(P,P) >>>>>>>>>>>>>>>>>>>>>> correctly emulates its
    input that it must emulate the first seven >>>>>>>>>>>>>>>>>>>>>> instructions of P. Because
    the seventh instruction of P repeats this >>>>>>>>>>>>>>>>>>>>>> process we know with
    complete certainty that the correct and >>>>>>>>>>>>>>>>>>>>>> complete emulation of P by H
    would never reach its final “ret” instruction, >>>>>>>>>>>>>>>>>>>>>> thus never halts.

    We are going around and around and around in >>>>>>>>>>>>>>>>>>>>> circles. I will try again:

    If you replace the opcodes "EB FE" at 00001369 >>>>>>>>>>>>>>>>>>>>> with the opcodes "90 90"
    then your H gets the answer wrong: P should have >>>>>>>>>>>>>>>>>>>>> halted.

    /Flibble


    As I already said before this is merely your >>>>>>>>>>>>>>>>>>>> cluelessness that when H(P,P) is invoked the >>>>>>>>>>>>>>>>>>>> correct x86 emulation of the input to H(P,P) >>>>>>>>>>>>>>>>>>>> makes and code after [0000135d] unreachable. >>>>>>>>>>>>>>>>>>>
    Wrong, because when that H return the value 0, it >>>>>>>>>>>>>>>>>>> will get there.
    Like I said people that are dumber than a box of >>>>>>>>>>>>>>>>>> rocks won't be able to correctly understand this. >>>>>>>>>>>>>>>>>>
    When H(P,P) is invoked the correctly emulated input >>>>>>>>>>>>>>>>>> to H(P,P) cannot possibly reach any instruction >>>>>>>>>>>>>>>>>> beyond [0000135d].

    So, you are defining that you H(P,P) never returns >>>>>>>>>>>>>>>>> because it is caught in the infinite rcursion. >>>>>>>>>>>>>>>>>
    Thats fine, just says it can't be the correctly >>>>>>>>>>>>>>>>> answering decider you claim it to be.

    I have corrected you on this too many times. >>>>>>>>>>>>>>>>

    How. You need to define what H(P,P) actually does. >>>>>>>>>>>>>>
    I have explained that too many times.

    To understand that H(P,P)==0 is correct we only need to >>>>>>>>>>>>>> know that H performs a correct x86 emulation of its >>>>>>>>>>>>>> input and then examine the execution trace.

    And a CORRECT emulation of the code will Halt if H(P,P) >>>>>>>>>>>>> returns 0, which it can only do if it does not actually >>>>>>>>>>>>> do a correct emulation

    The correctly emulated input to H(P,P) never gets past >>>>>>>>>>>> its machine address [0000135d].



    Only if H actually doesn't return 0. Yes, H can't
    correctly return 0 if it correctly emulates its input, >>>>>>>>>>> but you can't drop that requirement.

    void P(u32 x)
    {
       if (H(x, x))
         HERE: goto HERE;
       return;
    }

    int main()
    {
       Output("Input_Halts = ", H((u32)P, (u32)P));
    }

    When H returns 0 it does not returns 0 to P it returns 0 to >>>>>>>>>> main().

    But it also return 0 to the computation P(P), maybe not the >>>>>>>>> copy that it is simulating, since it aborts that before it >>>>>>>>> get to it,

    Finally you are not stupid or deceptive.

    If H never returns a value to P then H is not a halting
    decider; if H returns a value of 0 to main() when P halts
    then H is not a halting decider.

    H is not a halting decider; H is a simulation detector, S.

    /Flibble


    In other words you are saying the infintely nested emulation
    only excutes for a few steps and then it stops on its own.

    I am saying that your H is not a halting decider; I am saying
    that your H is just a simulation detector, S.

    /Flibble


    You are saying that you simply "don't believe in" simulating halt
    deciders.

    You haven't got a simulating halt decider, what you have got is a
    simulation detector.

    /Flibble


    It is an easily verified fact that H does correctly decide the halt
    status of its input.

    void Infinite_Loop()
    {
    HERE: goto HERE;
    }

    int main()
    {
    Output("Input_Halts = ", H0(Infinite_Loop));
    }

    _Infinite_Loop()
    [00001342](01) 55 push ebp
    [00001343](02) 8bec mov ebp,esp
    [00001345](02) ebfe jmp 00001345
    [00001347](01) 5d pop ebp
    [00001348](01) c3 ret
    Size in bytes:(0007) [00001348]

    _main()
    [00001372](01) 55 push ebp
    [00001373](02) 8bec mov ebp,esp
    [00001375](05) 6842130000 push 00001342
    [0000137a](05) e833fdffff call 000010b2
    [0000137f](03) 83c404 add esp,+04
    [00001382](01) 50 push eax
    [00001383](05) 6823040000 push 00000423
    [00001388](05) e8e5f0ffff call 00000472
    [0000138d](03) 83c408 add esp,+08
    [00001390](02) 33c0 xor eax,eax
    [00001392](01) 5d pop ebp
    [00001393](01) c3 ret
    Size in bytes:(0034) [00001393]

    machine stack stack machine assembly
    address address data code language
    ======== ======== ======== ========= =============
    [00001372][0010228f][00000000] 55 push ebp
    [00001373][0010228f][00000000] 8bec mov ebp,esp
    [00001375][0010228b][00001342] 6842130000 push 00001342 // push
    _Infinite_Loop
    [0000137a][00102287][0000137f] e833fdffff call 000010b2 // call H0

    Begin Local Halt Decider Simulation Execution Trace Stored
    at:212343 [00001342][00212333][00212337] 55 push ebp
    [00001343][00212333][00212337] 8bec mov ebp,esp
    [00001345][00212333][00212337] ebfe jmp 00001345
    [00001345][00212333][00212337] ebfe jmp 00001345
    Local Halt Decider: Infinite Loop Detected Simulation Stopped

    [0000137f][0010228f][00000000] 83c404 add esp,+04
    [00001382][0010228b][00000000] 50 push eax
    [00001383][00102287][00000423] 6823040000 push 00000423
    [00001388][00102287][00000423] e8e5f0ffff call 00000472
    Input_Halts = 0
    [0000138d][0010228f][00000000] 83c408 add esp,+08
    [00001390][0010228f][00000000] 33c0 xor eax,eax
    [00001392][00102293][00100000] 5d pop ebp
    [00001393][00102297][00000004] c3 ret
    Number of Instructions Executed(680)

    int Sum(int X, int Y)
    {
    return X + Y;
    }

    int main()
    {
    Output("Input_Halts = ", H2(Sum, 3, 4));
    }

    _Sum()
    [000012b6](01) 55 push ebp
    [000012b7](02) 8bec mov ebp,esp
    [000012b9](03) 8b4508 mov eax,[ebp+08]
    [000012bc](03) 03450c add eax,[ebp+0c]
    [000012bf](01) 5d pop ebp
    [000012c0](01) c3 ret
    Size in bytes:(0011) [000012c0]

    _main()
    [00001316](01) 55 push ebp
    [00001317](02) 8bec mov ebp,esp
    [00001319](02) 6a04 push +04
    [0000131b](02) 6a03 push +03
    [0000131d](05) 68b6120000 push 000012b6
    [00001322](05) e85ffaffff call 00000d86
    [00001327](03) 83c40c add esp,+0c
    [0000132a](01) 50 push eax
    [0000132b](05) 6807040000 push 00000407
    [00001330](05) e821f1ffff call 00000456
    [00001335](03) 83c408 add esp,+08
    [00001338](02) 33c0 xor eax,eax
    [0000133a](01) 5d pop ebp
    [0000133b](01) c3 ret
    Size in bytes:(0038) [0000133b]

    machine stack stack machine assembly
    address address data code language
    ======== ======== ======== ========= =============
    ...[00001316][001021d7][00000000] 55 push ebp
    ...[00001317][001021d7][00000000] 8bec mov ebp,esp
    ...[00001319][001021d3][00000004] 6a04 push +04
    ...[0000131b][001021cf][00000003] 6a03 push +03
    ...[0000131d][001021cb][000012b6] 68b6120000 push 000012b6
    ...[00001322][001021c7][00001327] e85ffaffff call 00000d86

    Begin Local Halt Decider Simulation Execution Trace Stored
    at:21228b ...[000012b6][00212273][00212277] 55 push
    ebp ...[000012b7][00212273][00212277] 8bec mov ebp,esp
    ...[000012b9][00212273][00212277] 8b4508 mov eax,[ebp+08]
    ...[000012bc][00212273][00212277] 03450c add eax,[ebp+0c]
    ...[000012bf][00212277][00000e54] 5d pop ebp
    ...[000012c0][0021227b][00000003] c3 ret
    ...[00001327][001021d7][00000000] 83c40c add esp,+0c
    ...[0000132a][001021d3][00000001] 50 push eax
    ...[0000132b][001021cf][00000407] 6807040000 push 00000407
    ---[00001330][001021cf][00000407] e821f1ffff call 00000456
    Input_Halts = 1
    ...[00001335][001021d7][00000000] 83c408 add esp,+08
    ...[00001338][001021d7][00000000] 33c0 xor eax,eax
    ...[0000133a][001021db][00100000] 5d pop ebp
    ...[0000133b][001021df][00000004] c3 ret
    Number of Instructions Executed(660)

    All you are showing here is that your H can decide the halt status
    of two trivial cases however you have not shown that H can decide
    the halt status of non-trivial cases.


    You said:
    "You haven't got a simulating halt decider"
    Apologize and we can move on.

    I posted four paragraphs but you ignored three of them. Lets try again.

    All you are showing here is that your H can decide the halt status of
    two trivial cases however you have not shown that H can decide the halt
    status of non-trivial cases.

    Publish the source code of your halt decider so we can see what classes
    of programs your H can decide.

    I am interested in deciding the halt status of programs containing
    non-trivial branching logic predicated on arbitrary program input.

    Crucially if your H cannot return an answer for an arbitrary
    non-halting program in finite time then it isn't a halt decider.

    /Flibble

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mr Flibble@21:1/5 to olcott on Fri Jun 10 14:23:23 2022
    XPost: comp.theory, sci.logic, sci.math

    On Fri, 10 Jun 2022 08:05:57 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/10/2022 6:11 AM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:35:05 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 5:27 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:18:38 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 5:15 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:09:08 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 4:54 PM, Richard Damon wrote:
    On 6/9/22 5:29 PM, olcott wrote:
    On 6/9/2022 4:13 PM, Richard Damon wrote:

    On 6/9/22 5:00 PM, olcott wrote:
    On 6/9/2022 3:25 PM, Richard Damon wrote:
    On 6/9/22 4:13 PM, olcott wrote:
    On 6/9/2022 2:57 PM, Richard Damon wrote:
    On 6/9/22 3:52 PM, olcott wrote:
    On 6/9/2022 2:38 PM, Richard Damon wrote:

    On 6/9/22 3:26 PM, olcott wrote:
    On 6/9/2022 1:12 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>> On 6/9/22 1:55 PM, olcott wrote:
    On 6/9/2022 12:46 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 12:39:32 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 12:28 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 12:15:24 -0500
    olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 12:06 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 12:54 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 11:34 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 11:47 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> void P(u32 x)
    {
         if (H(x, x))
           HERE: goto HERE; >>>>>>>>>>>>>>>>>>>>>>>>>>      return;
    }

    int main()
    {
         P(P);
    }

    _P()
    [000012e7](01)  55              push ebp
    [000012e8](02)  8bec            mov ebp,esp
    [000012ea](03)  8b4508          mov >>>>>>>>>>>>>>>>>>>>>>>>>> eax,[ebp+08] [000012ed](01)  50 >>>>>>>>>>>>>>>>>>>>>>>>>> push eax [000012ee](03)  8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08] [000012f1](01)  51 >>>>>>>>>>>>>>>>>>>>>>>>>> push ecx [000012f2](05)  e880feffff >>>>>>>>>>>>>>>>>>>>>>>>>> call 00001177 // call H [000012f7](03) >>>>>>>>>>>>>>>>>>>>>>>>>> 83c408 add esp,+08 [000012fa](02)  85c0 >>>>>>>>>>>>>>>>>>>>>>>>>> test eax,eax [000012fc](02)  7402 >>>>>>>>>>>>>>>>>>>>>>>>>> jz 00001300 [000012fe](02)  ebfe >>>>>>>>>>>>>>>>>>>>>>>>>> jmp 000012fe [00001300](01)  5d >>>>>>>>>>>>>>>>>>>>>>>>>> pop ebp [00001301](01)  c3              ret
    Size in bytes:(0027) [00001301] >>>>>>>>>>>>>>>>>>>>>>>>>>
    _main()
    [00001307](01)  55              push ebp
    [00001308](02)  8bec            mov ebp,esp
    [0000130a](05)  68e7120000      push >>>>>>>>>>>>>>>>>>>>>>>>>> 000012e7 // push P [0000130f](05) >>>>>>>>>>>>>>>>>>>>>>>>>> e8d3ffffff call 000012e7 // call P >>>>>>>>>>>>>>>>>>>>>>>>>> [00001314](03) 83c404 add esp,+04 >>>>>>>>>>>>>>>>>>>>>>>>>> [00001317](02)  33c0 xor eax,eax >>>>>>>>>>>>>>>>>>>>>>>>>> [00001319](01)  5d pop ebp [0000131a](01) >>>>>>>>>>>>>>>>>>>>>>>>>> c3              ret Size in bytes:(0020)
    [0000131a]

        machine   stack     stack >>>>>>>>>>>>>>>>>>>>>>>>>> machine assembly address   address   data >>>>>>>>>>>>>>>>>>>>>>>>>>     code language ========  ======== >>>>>>>>>>>>>>>>>>>>>>>>>> ======== ========= ============= >>>>>>>>>>>>>>>>>>>>>>>>>> [00001307][00102190][00000000] 55 >>>>>>>>>>>>>>>>>>>>>>>>>> push ebp [00001308][00102190][00000000] >>>>>>>>>>>>>>>>>>>>>>>>>> 8bec mov ebp,esp
    [0000130a][0010218c][000012e7] 68e7120000 >>>>>>>>>>>>>>>>>>>>>>>>>> push 000012e7 // push P
    [0000130f][00102188][00001314] e8d3ffffff >>>>>>>>>>>>>>>>>>>>>>>>>> call 000012e7 // call P
    [000012e7][00102184][00102190] 55 push ebp >>>>>>>>>>>>>>>>>>>>>>>>>> // enter executed P
    [000012e8][00102184][00102190] 8bec >>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp [000012ea][00102184][00102190] >>>>>>>>>>>>>>>>>>>>>>>>>> 8b4508 mov eax,[ebp+08]
    [000012ed][00102180][000012e7] 50 push eax >>>>>>>>>>>>>>>>>>>>>>>>>>      // push P
    [000012ee][00102180][000012e7] 8b4d08 mov >>>>>>>>>>>>>>>>>>>>>>>>>> ecx,[ebp+08]
    [000012f1][0010217c][000012e7] 51 push ecx >>>>>>>>>>>>>>>>>>>>>>>>>> // push P [000012f2][00102178][000012f7] >>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H >>>>>>>>>>>>>>>>>>>>>>>>>>
    Begin Local Halt Decider Simulation >>>>>>>>>>>>>>>>>>>>>>>>>> Execution Trace Stored
    at:212244 [000012e7][00212230][00212234] 55 >>>>>>>>>>>>>>>>>>>>>>>>>> push ebp // enter emulated P >>>>>>>>>>>>>>>>>>>>>>>>>> [000012e8][00212230][00212234] 8bec >>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp [000012ea][00212230][00212234] >>>>>>>>>>>>>>>>>>>>>>>>>> 8b4508 mov eax,[ebp+08]
    [000012ed][0021222c][000012e7] 50 >>>>>>>>>>>>>>>>>>>>>>>>>> push eax      //
    push P [000012ee][0021222c][000012e7] >>>>>>>>>>>>>>>>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08]
    [000012f1][00212228][000012e7] 51 push ecx >>>>>>>>>>>>>>>>>>>>>>>>>> // push P [000012f2][00212224][000012f7] >>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H >>>>>>>>>>>>>>>>>>>>>>>>>
    So, by what instruction reference manual is >>>>>>>>>>>>>>>>>>>>>>>>> a call 00001177
    followedby the execution of the instruction >>>>>>>>>>>>>>>>>>>>>>>>> at 000012e7.

    Your "CPU" is broken, or emulation >>>>>>>>>>>>>>>>>>>>>>>>> incorrect.

    FAIL.
    [000012e7][0025cc58][0025cc5c] 55 >>>>>>>>>>>>>>>>>>>>>>>>>> push ebp      //
    enter emulated P
    [000012e8][0025cc58][0025cc5c] 8bec >>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp [000012ea][0025cc58][0025cc5c] >>>>>>>>>>>>>>>>>>>>>>>>>> 8b4508 mov eax,[ebp+08]
    [000012ed][0025cc54][000012e7] 50 >>>>>>>>>>>>>>>>>>>>>>>>>> push eax      //
    push P [000012ee][0025cc54][000012e7] >>>>>>>>>>>>>>>>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08]
    [000012f1][0025cc50][000012e7] 51 push ecx >>>>>>>>>>>>>>>>>>>>>>>>>> // push P [000012f2][0025cc4c][000012f7] >>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H Local >>>>>>>>>>>>>>>>>>>>>>>>>> Halt Decider: Infinite Recursion >>>>>>>>>>>>>>>>>>>>>>>>>> Detected Simulation Stopped >>>>>>>>>>>>>>>>>>>>>>>>>>
    It is completely obvious that when H(P,P) >>>>>>>>>>>>>>>>>>>>>>>>>> correctly emulates
    its input that it must emulate the first >>>>>>>>>>>>>>>>>>>>>>>>>> seven instructions of
    P. Because the seventh instruction of P >>>>>>>>>>>>>>>>>>>>>>>>>> repeats this process we
    know with complete certainty that the >>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete
    emulation of P by H would never reach its >>>>>>>>>>>>>>>>>>>>>>>>>> final “ret” instruction, thus never halts. >>>>>>>>>>>>>>>>>>>>>>>>>>

    Problem, the 7th intruction DOESN't "Just >>>>>>>>>>>>>>>>>>>>>>>>> repeat the procedure",
    because that H always has the option to >>>>>>>>>>>>>>>>>>>>>>>>> abort its simulation,
    just like this onne did, and return to its P >>>>>>>>>>>>>>>>>>>>>>>>> and see it halt.
    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND >>>>>>>>>>>>>>>>>>>>>>>> THIS IS NO ACTUAL
    REBUTTAL AT ALL:

    The partial correct x86 emulation of the >>>>>>>>>>>>>>>>>>>>>>>> input to H(P,P) conclusively proves that the >>>>>>>>>>>>>>>>>>>>>>>> complete and correct x86 emulation >>>>>>>>>>>>>>>>>>>>>>>> would never stop running.


    You SAY that, but you don't answer the actual >>>>>>>>>>>>>>>>>>>>>>> questions about HOW.

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND >>>>>>>>>>>>>>>>>>>>>> THIS IS NO EVIDENCE
    WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE >>>>>>>>>>>>>>>>>>>>>> THAT THE CORRECT
    PARTIAL EMULATION OF THE INPUT TO H(P,P) >>>>>>>>>>>>>>>>>>>>>> CONCLUSIVELY PROVES THAT
    THE CORRECT AND COMPLETE X86 EMULATION OF THE >>>>>>>>>>>>>>>>>>>>>> INPUT TO H(P,P)
    WOULD NEVER STOP RUNNING.

    It is completely obvious that when H(P,P) >>>>>>>>>>>>>>>>>>>>>> correctly emulates its
    input that it must emulate the first seven >>>>>>>>>>>>>>>>>>>>>> instructions of P.
    Because the seventh instruction of P repeats >>>>>>>>>>>>>>>>>>>>>> this process we know
    with complete certainty that the correct and >>>>>>>>>>>>>>>>>>>>>> complete emulation of
    P by H would never reach its final “ret” >>>>>>>>>>>>>>>>>>>>>> instruction, thus never
    halts.

    If P should have halted (i.e. no infinite loop) >>>>>>>>>>>>>>>>>>>>> then your simulation
    detector, S (not H), gets the answer wrong. >>>>>>>>>>>>>>>>>>>>> You S is NOT a halting
    decider.

    /Flibble

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS >>>>>>>>>>>>>>>>>>>> IS NO ACTUAL
    REBUTTAL AT ALL.

    _P()
    [00001352](01)  55              push ebp >>>>>>>>>>>>>>>>>>>> [00001353](02)  8bec            mov ebp,esp >>>>>>>>>>>>>>>>>>>> [00001355](03)  8b4508          mov eax,[ebp+08]
    [00001358](01)  50              push eax      //
    push P [00001359](03)  8b4d08          mov >>>>>>>>>>>>>>>>>>>> ecx,[ebp+08] [0000135c](01)  51              push
    ecx      // push P [0000135d](05)  e840feffff >>>>>>>>>>>>>>>>>>>> call 000011a2 // call H [00001362](03)  83c408 >>>>>>>>>>>>>>>>>>>>    add esp,+08 [00001365](02)  85c0 >>>>>>>>>>>>>>>>>>>> test eax,eax [00001367](02)  7402            jz
    0000136b [00001369](02)  ebfe            jmp >>>>>>>>>>>>>>>>>>>> 00001369 [0000136b](01)  5d              pop ebp
    [0000136c](01)  c3              ret >>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]

    It is completely obvious that when H(P,P) >>>>>>>>>>>>>>>>>>>> correctly emulates its
    input that it must emulate the first seven >>>>>>>>>>>>>>>>>>>> instructions of P. Because
    the seventh instruction of P repeats this process >>>>>>>>>>>>>>>>>>>> we know with
    complete certainty that the correct and complete >>>>>>>>>>>>>>>>>>>> emulation of P by H
    would never reach its final “ret” instruction, >>>>>>>>>>>>>>>>>>>> thus never halts.

    We are going around and around and around in >>>>>>>>>>>>>>>>>>> circles. I will try again:

    If you replace the opcodes "EB FE" at 00001369 >>>>>>>>>>>>>>>>>>> with the opcodes "90 90"
    then your H gets the answer wrong: P should have >>>>>>>>>>>>>>>>>>> halted.

    /Flibble


    As I already said before this is merely your >>>>>>>>>>>>>>>>>> cluelessness that when H(P,P) is invoked the >>>>>>>>>>>>>>>>>> correct x86 emulation of the input to H(P,P) makes >>>>>>>>>>>>>>>>>> and code after [0000135d] unreachable.

    Wrong, because when that H return the value 0, it >>>>>>>>>>>>>>>>> will get there.
    Like I said people that are dumber than a box of >>>>>>>>>>>>>>>> rocks won't be able to correctly understand this. >>>>>>>>>>>>>>>>
    When H(P,P) is invoked the correctly emulated input >>>>>>>>>>>>>>>> to H(P,P) cannot possibly reach any instruction >>>>>>>>>>>>>>>> beyond [0000135d].

    So, you are defining that you H(P,P) never returns >>>>>>>>>>>>>>> because it is caught in the infinite rcursion. >>>>>>>>>>>>>>>
    Thats fine, just says it can't be the correctly >>>>>>>>>>>>>>> answering decider you claim it to be.

    I have corrected you on this too many times.


    How. You need to define what H(P,P) actually does. >>>>>>>>>>>>
    I have explained that too many times.

    To understand that H(P,P)==0 is correct we only need to >>>>>>>>>>>> know that H performs a correct x86 emulation of its input >>>>>>>>>>>> and then examine the execution trace.

    And a CORRECT emulation of the code will Halt if H(P,P) >>>>>>>>>>> returns 0, which it can only do if it does not actually >>>>>>>>>>> do a correct emulation

    The correctly emulated input to H(P,P) never gets past its >>>>>>>>>> machine address [0000135d].



    Only if H actually doesn't return 0. Yes, H can't correctly >>>>>>>>> return 0 if it correctly emulates its input, but you can't >>>>>>>>> drop that requirement.

    void P(u32 x)
    {
       if (H(x, x))
         HERE: goto HERE;
       return;
    }

    int main()
    {
       Output("Input_Halts = ", H((u32)P, (u32)P));
    }

    When H returns 0 it does not returns 0 to P it returns 0 to
    main().

    But it also return 0 to the computation P(P), maybe not the
    copy that it is simulating, since it aborts that before it
    get to it,

    Finally you are not stupid or deceptive.

    If H never returns a value to P then H is not a halting decider;
    if H returns a value of 0 to main() when P halts then H is not a
    halting decider.

    H is not a halting decider; H is a simulation detector, S.

    /Flibble


    In other words you are saying the infintely nested emulation only
    excutes for a few steps and then it stops on its own.

    I am saying that your H is not a halting decider; I am saying that
    your H is just a simulation detector, S.

    /Flibble


    You are saying that you simply "don't believe in" simulating halt
    deciders.

    You haven't got a simulating halt decider, what you have got is a simulation detector.

    /Flibble


    It is an easily verified fact that H does correctly decide the halt
    status of its input.

    void Infinite_Loop()
    {
    HERE: goto HERE;
    }

    int main()
    {
    Output("Input_Halts = ", H0(Infinite_Loop));
    }

    _Infinite_Loop()
    [00001342](01) 55 push ebp
    [00001343](02) 8bec mov ebp,esp
    [00001345](02) ebfe jmp 00001345
    [00001347](01) 5d pop ebp
    [00001348](01) c3 ret
    Size in bytes:(0007) [00001348]

    _main()
    [00001372](01) 55 push ebp
    [00001373](02) 8bec mov ebp,esp
    [00001375](05) 6842130000 push 00001342
    [0000137a](05) e833fdffff call 000010b2
    [0000137f](03) 83c404 add esp,+04
    [00001382](01) 50 push eax
    [00001383](05) 6823040000 push 00000423
    [00001388](05) e8e5f0ffff call 00000472
    [0000138d](03) 83c408 add esp,+08
    [00001390](02) 33c0 xor eax,eax
    [00001392](01) 5d pop ebp
    [00001393](01) c3 ret
    Size in bytes:(0034) [00001393]

    machine stack stack machine assembly
    address address data code language
    ======== ======== ======== ========= ============= [00001372][0010228f][00000000] 55 push ebp [00001373][0010228f][00000000] 8bec mov ebp,esp [00001375][0010228b][00001342] 6842130000 push 00001342 // push _Infinite_Loop
    [0000137a][00102287][0000137f] e833fdffff call 000010b2 // call H0

    Begin Local Halt Decider Simulation Execution Trace Stored at:212343 [00001342][00212333][00212337] 55 push ebp [00001343][00212333][00212337] 8bec mov ebp,esp [00001345][00212333][00212337] ebfe jmp 00001345 [00001345][00212333][00212337] ebfe jmp 00001345
    Local Halt Decider: Infinite Loop Detected Simulation Stopped

    [0000137f][0010228f][00000000] 83c404 add esp,+04 [00001382][0010228b][00000000] 50 push eax [00001383][00102287][00000423] 6823040000 push 00000423 [00001388][00102287][00000423] e8e5f0ffff call 00000472
    Input_Halts = 0
    [0000138d][0010228f][00000000] 83c408 add esp,+08 [00001390][0010228f][00000000] 33c0 xor eax,eax [00001392][00102293][00100000] 5d pop ebp [00001393][00102297][00000004] c3 ret
    Number of Instructions Executed(680)

    int Sum(int X, int Y)
    {
    return X + Y;
    }

    int main()
    {
    Output("Input_Halts = ", H2(Sum, 3, 4));
    }

    _Sum()
    [000012b6](01) 55 push ebp
    [000012b7](02) 8bec mov ebp,esp
    [000012b9](03) 8b4508 mov eax,[ebp+08]
    [000012bc](03) 03450c add eax,[ebp+0c]
    [000012bf](01) 5d pop ebp
    [000012c0](01) c3 ret
    Size in bytes:(0011) [000012c0]

    _main()
    [00001316](01) 55 push ebp
    [00001317](02) 8bec mov ebp,esp
    [00001319](02) 6a04 push +04
    [0000131b](02) 6a03 push +03
    [0000131d](05) 68b6120000 push 000012b6
    [00001322](05) e85ffaffff call 00000d86
    [00001327](03) 83c40c add esp,+0c
    [0000132a](01) 50 push eax
    [0000132b](05) 6807040000 push 00000407
    [00001330](05) e821f1ffff call 00000456
    [00001335](03) 83c408 add esp,+08
    [00001338](02) 33c0 xor eax,eax
    [0000133a](01) 5d pop ebp
    [0000133b](01) c3 ret
    Size in bytes:(0038) [0000133b]

    machine stack stack machine assembly
    address address data code language
    ======== ======== ======== ========= ============= ...[00001316][001021d7][00000000] 55 push ebp ...[00001317][001021d7][00000000] 8bec mov ebp,esp ...[00001319][001021d3][00000004] 6a04 push +04 ...[0000131b][001021cf][00000003] 6a03 push +03 ...[0000131d][001021cb][000012b6] 68b6120000 push 000012b6 ...[00001322][001021c7][00001327] e85ffaffff call 00000d86

    Begin Local Halt Decider Simulation Execution Trace Stored at:21228b ...[000012b6][00212273][00212277] 55 push ebp ...[000012b7][00212273][00212277] 8bec mov ebp,esp ...[000012b9][00212273][00212277] 8b4508 mov eax,[ebp+08] ...[000012bc][00212273][00212277] 03450c add eax,[ebp+0c] ...[000012bf][00212277][00000e54] 5d pop ebp ...[000012c0][0021227b][00000003] c3 ret ...[00001327][001021d7][00000000] 83c40c add esp,+0c ...[0000132a][001021d3][00000001] 50 push eax ...[0000132b][001021cf][00000407] 6807040000 push 00000407 ---[00001330][001021cf][00000407] e821f1ffff call 00000456
    Input_Halts = 1
    ...[00001335][001021d7][00000000] 83c408 add esp,+08 ...[00001338][001021d7][00000000] 33c0 xor eax,eax ...[0000133a][001021db][00100000] 5d pop ebp ...[0000133b][001021df][00000004] c3 ret
    Number of Instructions Executed(660)

    All you are showing here is that your H can decide the halt status of
    two trivial cases however you have not shown that H can decide the halt
    status of non-trivial cases.

    Publish the source code of your halt decider so we can see what classes
    of programs your H can decide.

    I am interested in deciding the halt status of programs containing
    non-trivial branching logic predicated on arbitrary program input.

    Crucially if your H cannot return an answer for an arbitrary
    non-halting program in finite time then it isn't a halt decider.

    /Flibble

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Mr Flibble on Fri Jun 10 08:27:28 2022
    XPost: comp.theory, sci.logic, sci.math

    On 6/10/2022 8:23 AM, Mr Flibble wrote:
    On Fri, 10 Jun 2022 08:05:57 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/10/2022 6:11 AM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:35:05 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 5:27 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:18:38 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 5:15 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:09:08 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 4:54 PM, Richard Damon wrote:
    On 6/9/22 5:29 PM, olcott wrote:
    On 6/9/2022 4:13 PM, Richard Damon wrote:

    On 6/9/22 5:00 PM, olcott wrote:
    On 6/9/2022 3:25 PM, Richard Damon wrote:
    On 6/9/22 4:13 PM, olcott wrote:
    On 6/9/2022 2:57 PM, Richard Damon wrote:
    On 6/9/22 3:52 PM, olcott wrote:
    On 6/9/2022 2:38 PM, Richard Damon wrote:

    On 6/9/22 3:26 PM, olcott wrote:
    On 6/9/2022 1:12 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 6/9/22 1:55 PM, olcott wrote:
    On 6/9/2022 12:46 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 12:39:32 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 12:28 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 12:15:24 -0500 >>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 12:06 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 12:54 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 11:34 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 11:47 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> void P(u32 x)
    {
         if (H(x, x)) >>>>>>>>>>>>>>>>>>>>>>>>>>>>        HERE: goto HERE; >>>>>>>>>>>>>>>>>>>>>>>>>>>>      return;
    }

    int main()
    {
         P(P);
    }

    _P()
    [000012e7](01)  55              push ebp
    [000012e8](02)  8bec            mov ebp,esp
    [000012ea](03)  8b4508          mov >>>>>>>>>>>>>>>>>>>>>>>>>>>> eax,[ebp+08] [000012ed](01)  50 >>>>>>>>>>>>>>>>>>>>>>>>>>>> push eax [000012ee](03)  8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08] [000012f1](01)  51 >>>>>>>>>>>>>>>>>>>>>>>>>>>> push ecx [000012f2](05)  e880feffff >>>>>>>>>>>>>>>>>>>>>>>>>>>> call 00001177 // call H [000012f7](03) >>>>>>>>>>>>>>>>>>>>>>>>>>>> 83c408 add esp,+08 [000012fa](02)  85c0 >>>>>>>>>>>>>>>>>>>>>>>>>>>> test eax,eax [000012fc](02)  7402 >>>>>>>>>>>>>>>>>>>>>>>>>>>> jz 00001300 [000012fe](02)  ebfe >>>>>>>>>>>>>>>>>>>>>>>>>>>> jmp 000012fe [00001300](01)  5d >>>>>>>>>>>>>>>>>>>>>>>>>>>> pop ebp [00001301](01)  c3              ret
    Size in bytes:(0027) [00001301] >>>>>>>>>>>>>>>>>>>>>>>>>>>>
    _main()
    [00001307](01)  55              push ebp
    [00001308](02)  8bec            mov ebp,esp
    [0000130a](05)  68e7120000      push >>>>>>>>>>>>>>>>>>>>>>>>>>>> 000012e7 // push P [0000130f](05) >>>>>>>>>>>>>>>>>>>>>>>>>>>> e8d3ffffff call 000012e7 // call P >>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001314](03) 83c404 add esp,+04 >>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001317](02)  33c0 xor eax,eax >>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001319](01)  5d pop ebp [0000131a](01) >>>>>>>>>>>>>>>>>>>>>>>>>>>> c3              ret Size in bytes:(0020)
    [0000131a]

        machine   stack     stack >>>>>>>>>>>>>>>>>>>>>>>>>>>> machine assembly address   address   data >>>>>>>>>>>>>>>>>>>>>>>>>>>>     code language ========  ======== >>>>>>>>>>>>>>>>>>>>>>>>>>>> ======== ========= ============= >>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001307][00102190][00000000] 55 >>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp [00001308][00102190][00000000] >>>>>>>>>>>>>>>>>>>>>>>>>>>> 8bec mov ebp,esp
    [0000130a][0010218c][000012e7] 68e7120000 >>>>>>>>>>>>>>>>>>>>>>>>>>>> push 000012e7 // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000130f][00102188][00001314] e8d3ffffff >>>>>>>>>>>>>>>>>>>>>>>>>>>> call 000012e7 // call P >>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e7][00102184][00102190] 55 push ebp >>>>>>>>>>>>>>>>>>>>>>>>>>>> // enter executed P
    [000012e8][00102184][00102190] 8bec >>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp [000012ea][00102184][00102190] >>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4508 mov eax,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ed][00102180][000012e7] 50 push eax >>>>>>>>>>>>>>>>>>>>>>>>>>>>      // push P
    [000012ee][00102180][000012e7] 8b4d08 mov >>>>>>>>>>>>>>>>>>>>>>>>>>>> ecx,[ebp+08]
    [000012f1][0010217c][000012e7] 51 push ecx >>>>>>>>>>>>>>>>>>>>>>>>>>>> // push P [000012f2][00102178][000012f7] >>>>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H >>>>>>>>>>>>>>>>>>>>>>>>>>>>
    Begin Local Halt Decider Simulation >>>>>>>>>>>>>>>>>>>>>>>>>>>> Execution Trace Stored >>>>>>>>>>>>>>>>>>>>>>>>>>>> at:212244 [000012e7][00212230][00212234] 55 >>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp // enter emulated P >>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e8][00212230][00212234] 8bec >>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp [000012ea][00212230][00212234] >>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4508 mov eax,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ed][0021222c][000012e7] 50 >>>>>>>>>>>>>>>>>>>>>>>>>>>> push eax      //
    push P [000012ee][0021222c][000012e7] >>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f1][00212228][000012e7] 51 push ecx >>>>>>>>>>>>>>>>>>>>>>>>>>>> // push P [000012f2][00212224][000012f7] >>>>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H >>>>>>>>>>>>>>>>>>>>>>>>>>>
    So, by what instruction reference manual is >>>>>>>>>>>>>>>>>>>>>>>>>>> a call 00001177
    followedby the execution of the instruction >>>>>>>>>>>>>>>>>>>>>>>>>>> at 000012e7.

    Your "CPU" is broken, or emulation >>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect.

    FAIL.
    [000012e7][0025cc58][0025cc5c] 55 >>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp      //
    enter emulated P
    [000012e8][0025cc58][0025cc5c] 8bec >>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp [000012ea][0025cc58][0025cc5c] >>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4508 mov eax,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ed][0025cc54][000012e7] 50 >>>>>>>>>>>>>>>>>>>>>>>>>>>> push eax      //
    push P [000012ee][0025cc54][000012e7] >>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f1][0025cc50][000012e7] 51 push ecx >>>>>>>>>>>>>>>>>>>>>>>>>>>> // push P [000012f2][0025cc4c][000012f7] >>>>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H Local >>>>>>>>>>>>>>>>>>>>>>>>>>>> Halt Decider: Infinite Recursion >>>>>>>>>>>>>>>>>>>>>>>>>>>> Detected Simulation Stopped >>>>>>>>>>>>>>>>>>>>>>>>>>>>
    It is completely obvious that when H(P,P) >>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly emulates
    its input that it must emulate the first >>>>>>>>>>>>>>>>>>>>>>>>>>>> seven instructions of
    P. Because the seventh instruction of P >>>>>>>>>>>>>>>>>>>>>>>>>>>> repeats this process we >>>>>>>>>>>>>>>>>>>>>>>>>>>> know with complete certainty that the >>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete
    emulation of P by H would never reach its >>>>>>>>>>>>>>>>>>>>>>>>>>>> final “ret” instruction, thus never halts. >>>>>>>>>>>>>>>>>>>>>>>>>>>>

    Problem, the 7th intruction DOESN't "Just >>>>>>>>>>>>>>>>>>>>>>>>>>> repeat the procedure",
    because that H always has the option to >>>>>>>>>>>>>>>>>>>>>>>>>>> abort its simulation,
    just like this onne did, and return to its P >>>>>>>>>>>>>>>>>>>>>>>>>>> and see it halt.
    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND >>>>>>>>>>>>>>>>>>>>>>>>>> THIS IS NO ACTUAL
    REBUTTAL AT ALL:

    The partial correct x86 emulation of the >>>>>>>>>>>>>>>>>>>>>>>>>> input to H(P,P) conclusively proves that the >>>>>>>>>>>>>>>>>>>>>>>>>> complete and correct x86 emulation >>>>>>>>>>>>>>>>>>>>>>>>>> would never stop running.


    You SAY that, but you don't answer the actual >>>>>>>>>>>>>>>>>>>>>>>>> questions about HOW.

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND >>>>>>>>>>>>>>>>>>>>>>>> THIS IS NO EVIDENCE
    WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE >>>>>>>>>>>>>>>>>>>>>>>> THAT THE CORRECT
    PARTIAL EMULATION OF THE INPUT TO H(P,P) >>>>>>>>>>>>>>>>>>>>>>>> CONCLUSIVELY PROVES THAT
    THE CORRECT AND COMPLETE X86 EMULATION OF THE >>>>>>>>>>>>>>>>>>>>>>>> INPUT TO H(P,P)
    WOULD NEVER STOP RUNNING.

    It is completely obvious that when H(P,P) >>>>>>>>>>>>>>>>>>>>>>>> correctly emulates its
    input that it must emulate the first seven >>>>>>>>>>>>>>>>>>>>>>>> instructions of P.
    Because the seventh instruction of P repeats >>>>>>>>>>>>>>>>>>>>>>>> this process we know
    with complete certainty that the correct and >>>>>>>>>>>>>>>>>>>>>>>> complete emulation of
    P by H would never reach its final “ret” >>>>>>>>>>>>>>>>>>>>>>>> instruction, thus never
    halts.

    If P should have halted (i.e. no infinite loop) >>>>>>>>>>>>>>>>>>>>>>> then your simulation
    detector, S (not H), gets the answer wrong. >>>>>>>>>>>>>>>>>>>>>>> You S is NOT a halting
    decider.

    /Flibble

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS >>>>>>>>>>>>>>>>>>>>>> IS NO ACTUAL
    REBUTTAL AT ALL.

    _P()
    [00001352](01)  55              push ebp >>>>>>>>>>>>>>>>>>>>>> [00001353](02)  8bec            mov ebp,esp >>>>>>>>>>>>>>>>>>>>>> [00001355](03)  8b4508          mov eax,[ebp+08]
    [00001358](01)  50              push eax      //
    push P [00001359](03)  8b4d08          mov >>>>>>>>>>>>>>>>>>>>>> ecx,[ebp+08] [0000135c](01)  51              push
    ecx      // push P [0000135d](05)  e840feffff >>>>>>>>>>>>>>>>>>>>>> call 000011a2 // call H [00001362](03)  83c408 >>>>>>>>>>>>>>>>>>>>>>    add esp,+08 [00001365](02)  85c0 >>>>>>>>>>>>>>>>>>>>>> test eax,eax [00001367](02)  7402            jz
    0000136b [00001369](02)  ebfe            jmp >>>>>>>>>>>>>>>>>>>>>> 00001369 [0000136b](01)  5d              pop ebp
    [0000136c](01)  c3              ret >>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]

    It is completely obvious that when H(P,P) >>>>>>>>>>>>>>>>>>>>>> correctly emulates its
    input that it must emulate the first seven >>>>>>>>>>>>>>>>>>>>>> instructions of P. Because
    the seventh instruction of P repeats this process >>>>>>>>>>>>>>>>>>>>>> we know with
    complete certainty that the correct and complete >>>>>>>>>>>>>>>>>>>>>> emulation of P by H
    would never reach its final “ret” instruction, >>>>>>>>>>>>>>>>>>>>>> thus never halts.

    We are going around and around and around in >>>>>>>>>>>>>>>>>>>>> circles. I will try again:

    If you replace the opcodes "EB FE" at 00001369 >>>>>>>>>>>>>>>>>>>>> with the opcodes "90 90"
    then your H gets the answer wrong: P should have >>>>>>>>>>>>>>>>>>>>> halted.

    /Flibble


    As I already said before this is merely your >>>>>>>>>>>>>>>>>>>> cluelessness that when H(P,P) is invoked the >>>>>>>>>>>>>>>>>>>> correct x86 emulation of the input to H(P,P) makes >>>>>>>>>>>>>>>>>>>> and code after [0000135d] unreachable.

    Wrong, because when that H return the value 0, it >>>>>>>>>>>>>>>>>>> will get there.
    Like I said people that are dumber than a box of >>>>>>>>>>>>>>>>>> rocks won't be able to correctly understand this. >>>>>>>>>>>>>>>>>>
    When H(P,P) is invoked the correctly emulated input >>>>>>>>>>>>>>>>>> to H(P,P) cannot possibly reach any instruction >>>>>>>>>>>>>>>>>> beyond [0000135d].

    So, you are defining that you H(P,P) never returns >>>>>>>>>>>>>>>>> because it is caught in the infinite rcursion. >>>>>>>>>>>>>>>>>
    Thats fine, just says it can't be the correctly >>>>>>>>>>>>>>>>> answering decider you claim it to be.

    I have corrected you on this too many times.


    How. You need to define what H(P,P) actually does. >>>>>>>>>>>>>>
    I have explained that too many times.

    To understand that H(P,P)==0 is correct we only need to >>>>>>>>>>>>>> know that H performs a correct x86 emulation of its input >>>>>>>>>>>>>> and then examine the execution trace.

    And a CORRECT emulation of the code will Halt if H(P,P) >>>>>>>>>>>>> returns 0, which it can only do if it does not actually >>>>>>>>>>>>> do a correct emulation

    The correctly emulated input to H(P,P) never gets past its >>>>>>>>>>>> machine address [0000135d].



    Only if H actually doesn't return 0. Yes, H can't correctly >>>>>>>>>>> return 0 if it correctly emulates its input, but you can't >>>>>>>>>>> drop that requirement.

    void P(u32 x)
    {
       if (H(x, x))
         HERE: goto HERE;
       return;
    }

    int main()
    {
       Output("Input_Halts = ", H((u32)P, (u32)P));
    }

    When H returns 0 it does not returns 0 to P it returns 0 to >>>>>>>>>> main().

    But it also return 0 to the computation P(P), maybe not the
    copy that it is simulating, since it aborts that before it
    get to it,

    Finally you are not stupid or deceptive.

    If H never returns a value to P then H is not a halting decider; >>>>>>> if H returns a value of 0 to main() when P halts then H is not a >>>>>>> halting decider.

    H is not a halting decider; H is a simulation detector, S.

    /Flibble


    In other words you are saying the infintely nested emulation only
    excutes for a few steps and then it stops on its own.

    I am saying that your H is not a halting decider; I am saying that
    your H is just a simulation detector, S.

    /Flibble


    You are saying that you simply "don't believe in" simulating halt
    deciders.

    You haven't got a simulating halt decider, what you have got is a
    simulation detector.

    /Flibble


    It is an easily verified fact that H does correctly decide the halt
    status of its input.

    void Infinite_Loop()
    {
    HERE: goto HERE;
    }

    int main()
    {
    Output("Input_Halts = ", H0(Infinite_Loop));
    }

    _Infinite_Loop()
    [00001342](01) 55 push ebp
    [00001343](02) 8bec mov ebp,esp
    [00001345](02) ebfe jmp 00001345
    [00001347](01) 5d pop ebp
    [00001348](01) c3 ret
    Size in bytes:(0007) [00001348]

    _main()
    [00001372](01) 55 push ebp
    [00001373](02) 8bec mov ebp,esp
    [00001375](05) 6842130000 push 00001342
    [0000137a](05) e833fdffff call 000010b2
    [0000137f](03) 83c404 add esp,+04
    [00001382](01) 50 push eax
    [00001383](05) 6823040000 push 00000423
    [00001388](05) e8e5f0ffff call 00000472
    [0000138d](03) 83c408 add esp,+08
    [00001390](02) 33c0 xor eax,eax
    [00001392](01) 5d pop ebp
    [00001393](01) c3 ret
    Size in bytes:(0034) [00001393]

    machine stack stack machine assembly
    address address data code language
    ======== ======== ======== ========= =============
    [00001372][0010228f][00000000] 55 push ebp
    [00001373][0010228f][00000000] 8bec mov ebp,esp
    [00001375][0010228b][00001342] 6842130000 push 00001342 // push
    _Infinite_Loop
    [0000137a][00102287][0000137f] e833fdffff call 000010b2 // call H0

    Begin Local Halt Decider Simulation Execution Trace Stored at:212343
    [00001342][00212333][00212337] 55 push ebp
    [00001343][00212333][00212337] 8bec mov ebp,esp
    [00001345][00212333][00212337] ebfe jmp 00001345
    [00001345][00212333][00212337] ebfe jmp 00001345
    Local Halt Decider: Infinite Loop Detected Simulation Stopped

    [0000137f][0010228f][00000000] 83c404 add esp,+04
    [00001382][0010228b][00000000] 50 push eax
    [00001383][00102287][00000423] 6823040000 push 00000423
    [00001388][00102287][00000423] e8e5f0ffff call 00000472
    Input_Halts = 0
    [0000138d][0010228f][00000000] 83c408 add esp,+08
    [00001390][0010228f][00000000] 33c0 xor eax,eax
    [00001392][00102293][00100000] 5d pop ebp
    [00001393][00102297][00000004] c3 ret
    Number of Instructions Executed(680)

    int Sum(int X, int Y)
    {
    return X + Y;
    }

    int main()
    {
    Output("Input_Halts = ", H2(Sum, 3, 4));
    }

    _Sum()
    [000012b6](01) 55 push ebp
    [000012b7](02) 8bec mov ebp,esp
    [000012b9](03) 8b4508 mov eax,[ebp+08]
    [000012bc](03) 03450c add eax,[ebp+0c]
    [000012bf](01) 5d pop ebp
    [000012c0](01) c3 ret
    Size in bytes:(0011) [000012c0]

    _main()
    [00001316](01) 55 push ebp
    [00001317](02) 8bec mov ebp,esp
    [00001319](02) 6a04 push +04
    [0000131b](02) 6a03 push +03
    [0000131d](05) 68b6120000 push 000012b6
    [00001322](05) e85ffaffff call 00000d86
    [00001327](03) 83c40c add esp,+0c
    [0000132a](01) 50 push eax
    [0000132b](05) 6807040000 push 00000407
    [00001330](05) e821f1ffff call 00000456
    [00001335](03) 83c408 add esp,+08
    [00001338](02) 33c0 xor eax,eax
    [0000133a](01) 5d pop ebp
    [0000133b](01) c3 ret
    Size in bytes:(0038) [0000133b]

    machine stack stack machine assembly
    address address data code language
    ======== ======== ======== ========= =============
    ...[00001316][001021d7][00000000] 55 push ebp
    ...[00001317][001021d7][00000000] 8bec mov ebp,esp
    ...[00001319][001021d3][00000004] 6a04 push +04
    ...[0000131b][001021cf][00000003] 6a03 push +03
    ...[0000131d][001021cb][000012b6] 68b6120000 push 000012b6
    ...[00001322][001021c7][00001327] e85ffaffff call 00000d86

    Begin Local Halt Decider Simulation Execution Trace Stored at:21228b
    ...[000012b6][00212273][00212277] 55 push ebp
    ...[000012b7][00212273][00212277] 8bec mov ebp,esp
    ...[000012b9][00212273][00212277] 8b4508 mov eax,[ebp+08]
    ...[000012bc][00212273][00212277] 03450c add eax,[ebp+0c]
    ...[000012bf][00212277][00000e54] 5d pop ebp
    ...[000012c0][0021227b][00000003] c3 ret
    ...[00001327][001021d7][00000000] 83c40c add esp,+0c
    ...[0000132a][001021d3][00000001] 50 push eax
    ...[0000132b][001021cf][00000407] 6807040000 push 00000407
    ---[00001330][001021cf][00000407] e821f1ffff call 00000456
    Input_Halts = 1
    ...[00001335][001021d7][00000000] 83c408 add esp,+08
    ...[00001338][001021d7][00000000] 33c0 xor eax,eax
    ...[0000133a][001021db][00100000] 5d pop ebp
    ...[0000133b][001021df][00000004] c3 ret
    Number of Instructions Executed(660)

    All you are showing here is that your H can decide the halt status of
    two trivial cases however you have not shown that H can decide the halt status of non-trivial cases.


    You said:
    "You haven't got a simulating halt decider"
    Apologize and we can move on.


    Publish the source code of your halt decider so we can see what classes
    of programs your H can decide.

    I am interested in deciding the halt status of programs containing non-trivial branching logic predicated on arbitrary program input.

    Crucially if your H cannot return an answer for an arbitrary
    non-halting program in finite time then it isn't a halt decider.

    /Flibble



    --
    Copyright 2022 Pete Olcott

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

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Mr Flibble on Fri Jun 10 08:31:54 2022
    XPost: comp.theory, sci.logic, sci.math

    On 6/10/2022 8:29 AM, Mr Flibble wrote:
    On Fri, 10 Jun 2022 08:27:28 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/10/2022 8:23 AM, Mr Flibble wrote:
    On Fri, 10 Jun 2022 08:05:57 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/10/2022 6:11 AM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:35:05 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 5:27 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:18:38 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 5:15 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:09:08 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 4:54 PM, Richard Damon wrote:
    On 6/9/22 5:29 PM, olcott wrote:
    On 6/9/2022 4:13 PM, Richard Damon wrote:

    On 6/9/22 5:00 PM, olcott wrote:
    On 6/9/2022 3:25 PM, Richard Damon wrote:
    On 6/9/22 4:13 PM, olcott wrote:
    On 6/9/2022 2:57 PM, Richard Damon wrote:
    On 6/9/22 3:52 PM, olcott wrote:
    On 6/9/2022 2:38 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>
    On 6/9/22 3:26 PM, olcott wrote:
    On 6/9/2022 1:12 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 6/9/22 1:55 PM, olcott wrote:
    On 6/9/2022 12:46 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 12:39:32 -0500 >>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>
    On 6/9/2022 12:28 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 12:15:24 -0500 >>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 12:06 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 12:54 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 11:34 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>
    On 6/9/22 11:47 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void P(u32 x)
    {
         if (H(x, x)) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>        HERE: goto HERE; >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>      return; >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }

    int main()
    {
         P(P); >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }

    _P()
    [000012e7](01)  55              push ebp
    [000012e8](02)  8bec            mov >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp [000012ea](03)  8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08] [000012ed](01)  50 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push eax [000012ee](03)  8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08] [000012f1](01)  51 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ecx [000012f2](05)  e880feffff >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> call 00001177 // call H [000012f7](03) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 83c408 add esp,+08 [000012fa](02)  85c0 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> test eax,eax [000012fc](02)  7402 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> jz 00001300 [000012fe](02)  ebfe >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> jmp 000012fe [00001300](01)  5d >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pop ebp [00001301](01)  c3 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ret Size in bytes:(0027) [00001301] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    _main()
    [00001307](01)  55              push ebp
    [00001308](02)  8bec            mov >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp [0000130a](05)  68e7120000 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push 000012e7 // push P [0000130f](05) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e8d3ffffff call 000012e7 // call P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001314](03) 83c404 add esp,+04 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001317](02)  33c0 xor eax,eax >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001319](01)  5d pop ebp [0000131a](01) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> c3              ret Size in bytes:(0020)
    [0000131a]

        machine   stack     stack >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine assembly address   address   data >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>     code language ========  ======== >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ======== ========= ============= >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001307][00102190][00000000] 55 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp [00001308][00102190][00000000] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8bec mov ebp,esp
    [0000130a][0010218c][000012e7] 68e7120000 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push 000012e7 // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000130f][00102188][00001314] e8d3ffffff >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> call 000012e7 // call P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e7][00102184][00102190] 55 push >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebp // enter executed P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e8][00102184][00102190] 8bec >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp
    [000012ea][00102184][00102190] 8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08]
    [000012ed][00102180][000012e7] 50 push >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> eax // push P
    [000012ee][00102180][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08]
    [000012f1][0010217c][000012e7] 51 push >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ecx // push P
    [000012f2][00102178][000012f7] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    Begin Local Halt Decider Simulation >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Execution Trace Stored >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> at:212244 [000012e7][00212230][00212234] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 55 push ebp // enter emulated P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e8][00212230][00212234] 8bec >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp
    [000012ea][00212230][00212234] 8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08]
    [000012ed][0021222c][000012e7] 50 push >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> eax      // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ee][0021222c][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08]
    [000012f1][00212228][000012e7] 51 push >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ecx // push P
    [000012f2][00212224][000012f7] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    So, by what instruction reference manual >>>>>>>>>>>>>>>>>>>>>>>>>>>>> is a call 00001177
    followedby the execution of the >>>>>>>>>>>>>>>>>>>>>>>>>>>>> instruction at 000012e7. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    Your "CPU" is broken, or emulation >>>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect.

    FAIL.
    [000012e7][0025cc58][0025cc5c] 55 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp      // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> enter emulated P
    [000012e8][0025cc58][0025cc5c] 8bec >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp
    [000012ea][0025cc58][0025cc5c] 8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08]
    [000012ed][0025cc54][000012e7] 50 push >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> eax      // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ee][0025cc54][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08]
    [000012f1][0025cc50][000012e7] 51 push >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ecx // push P
    [000012f2][0025cc4c][000012f7] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H Local >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halt Decider: Infinite Recursion >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Detected Simulation Stopped >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    It is completely obvious that when H(P,P) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly emulates >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input that it must emulate the first >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> seven instructions of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P. Because the seventh instruction of P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeats this process we >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> know with complete certainty that the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulation of P by H would never reach its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final “ret” instruction, thus never >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts.

    Problem, the 7th intruction DOESN't "Just >>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeat the procedure", >>>>>>>>>>>>>>>>>>>>>>>>>>>>> because that H always has the option to >>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort its simulation, >>>>>>>>>>>>>>>>>>>>>>>>>>>>> just like this onne did, and return to >>>>>>>>>>>>>>>>>>>>>>>>>>>>> its P and see it halt. >>>>>>>>>>>>>>>>>>>>>>>>>>>> THAT YOU ARE SIMPLY TOO STUPID TO >>>>>>>>>>>>>>>>>>>>>>>>>>>> UNDERSTAND THIS IS NO ACTUAL >>>>>>>>>>>>>>>>>>>>>>>>>>>> REBUTTAL AT ALL:

    The partial correct x86 emulation of the >>>>>>>>>>>>>>>>>>>>>>>>>>>> input to H(P,P) conclusively proves that >>>>>>>>>>>>>>>>>>>>>>>>>>>> the complete and correct x86 emulation >>>>>>>>>>>>>>>>>>>>>>>>>>>> would never stop running. >>>>>>>>>>>>>>>>>>>>>>>>>>>>

    You SAY that, but you don't answer the >>>>>>>>>>>>>>>>>>>>>>>>>>> actual questions about HOW. >>>>>>>>>>>>>>>>>>>>>>>>>>
    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND >>>>>>>>>>>>>>>>>>>>>>>>>> THIS IS NO EVIDENCE
    WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE >>>>>>>>>>>>>>>>>>>>>>>>>> THAT THE CORRECT
    PARTIAL EMULATION OF THE INPUT TO H(P,P) >>>>>>>>>>>>>>>>>>>>>>>>>> CONCLUSIVELY PROVES THAT
    THE CORRECT AND COMPLETE X86 EMULATION OF THE >>>>>>>>>>>>>>>>>>>>>>>>>> INPUT TO H(P,P)
    WOULD NEVER STOP RUNNING.

    It is completely obvious that when H(P,P) >>>>>>>>>>>>>>>>>>>>>>>>>> correctly emulates its
    input that it must emulate the first seven >>>>>>>>>>>>>>>>>>>>>>>>>> instructions of P.
    Because the seventh instruction of P repeats >>>>>>>>>>>>>>>>>>>>>>>>>> this process we know
    with complete certainty that the correct and >>>>>>>>>>>>>>>>>>>>>>>>>> complete emulation of
    P by H would never reach its final “ret” >>>>>>>>>>>>>>>>>>>>>>>>>> instruction, thus never
    halts.

    If P should have halted (i.e. no infinite >>>>>>>>>>>>>>>>>>>>>>>>> loop) then your simulation
    detector, S (not H), gets the answer wrong. >>>>>>>>>>>>>>>>>>>>>>>>> You S is NOT a halting
    decider.

    /Flibble

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND >>>>>>>>>>>>>>>>>>>>>>>> THIS IS NO ACTUAL
    REBUTTAL AT ALL.

    _P()
    [00001352](01)  55              push ebp >>>>>>>>>>>>>>>>>>>>>>>> [00001353](02)  8bec            mov ebp,esp
    [00001355](03)  8b4508          mov >>>>>>>>>>>>>>>>>>>>>>>> eax,[ebp+08] [00001358](01)  50 >>>>>>>>>>>>>>>>>>>>>>>> push eax      // push P [00001359](03)  8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>          mov ecx,[ebp+08] [0000135c](01)  51 >>>>>>>>>>>>>>>>>>>>>>>>            push ecx      // push P >>>>>>>>>>>>>>>>>>>>>>>> [0000135d](05)  e840feffff call 000011a2 // >>>>>>>>>>>>>>>>>>>>>>>> call H [00001362](03)  83c408 add esp,+08 >>>>>>>>>>>>>>>>>>>>>>>> [00001365](02)  85c0 test eax,eax >>>>>>>>>>>>>>>>>>>>>>>> [00001367](02)  7402            jz 0000136b
    [00001369](02)  ebfe            jmp 00001369
    [0000136b](01)  5d              pop ebp >>>>>>>>>>>>>>>>>>>>>>>> [0000136c](01)  c3              ret Size in
    bytes:(0027) [0000136c]

    It is completely obvious that when H(P,P) >>>>>>>>>>>>>>>>>>>>>>>> correctly emulates its
    input that it must emulate the first seven >>>>>>>>>>>>>>>>>>>>>>>> instructions of P. Because
    the seventh instruction of P repeats this >>>>>>>>>>>>>>>>>>>>>>>> process we know with
    complete certainty that the correct and >>>>>>>>>>>>>>>>>>>>>>>> complete emulation of P by H
    would never reach its final “ret” instruction, >>>>>>>>>>>>>>>>>>>>>>>> thus never halts.

    We are going around and around and around in >>>>>>>>>>>>>>>>>>>>>>> circles. I will try again:

    If you replace the opcodes "EB FE" at 00001369 >>>>>>>>>>>>>>>>>>>>>>> with the opcodes "90 90"
    then your H gets the answer wrong: P should have >>>>>>>>>>>>>>>>>>>>>>> halted.

    /Flibble


    As I already said before this is merely your >>>>>>>>>>>>>>>>>>>>>> cluelessness that when H(P,P) is invoked the >>>>>>>>>>>>>>>>>>>>>> correct x86 emulation of the input to H(P,P) >>>>>>>>>>>>>>>>>>>>>> makes and code after [0000135d] unreachable. >>>>>>>>>>>>>>>>>>>>>
    Wrong, because when that H return the value 0, it >>>>>>>>>>>>>>>>>>>>> will get there.
    Like I said people that are dumber than a box of >>>>>>>>>>>>>>>>>>>> rocks won't be able to correctly understand this. >>>>>>>>>>>>>>>>>>>>
    When H(P,P) is invoked the correctly emulated input >>>>>>>>>>>>>>>>>>>> to H(P,P) cannot possibly reach any instruction >>>>>>>>>>>>>>>>>>>> beyond [0000135d].

    So, you are defining that you H(P,P) never returns >>>>>>>>>>>>>>>>>>> because it is caught in the infinite rcursion. >>>>>>>>>>>>>>>>>>>
    Thats fine, just says it can't be the correctly >>>>>>>>>>>>>>>>>>> answering decider you claim it to be.

    I have corrected you on this too many times. >>>>>>>>>>>>>>>>>>

    How. You need to define what H(P,P) actually does. >>>>>>>>>>>>>>>>
    I have explained that too many times.

    To understand that H(P,P)==0 is correct we only need to >>>>>>>>>>>>>>>> know that H performs a correct x86 emulation of its >>>>>>>>>>>>>>>> input and then examine the execution trace.

    And a CORRECT emulation of the code will Halt if H(P,P) >>>>>>>>>>>>>>> returns 0, which it can only do if it does not actually >>>>>>>>>>>>>>> do a correct emulation

    The correctly emulated input to H(P,P) never gets past >>>>>>>>>>>>>> its machine address [0000135d].



    Only if H actually doesn't return 0. Yes, H can't
    correctly return 0 if it correctly emulates its input, >>>>>>>>>>>>> but you can't drop that requirement.

    void P(u32 x)
    {
       if (H(x, x))
         HERE: goto HERE;
       return;
    }

    int main()
    {
       Output("Input_Halts = ", H((u32)P, (u32)P)); >>>>>>>>>>>> }

    When H returns 0 it does not returns 0 to P it returns 0 to >>>>>>>>>>>> main().

    But it also return 0 to the computation P(P), maybe not the >>>>>>>>>>> copy that it is simulating, since it aborts that before it >>>>>>>>>>> get to it,

    Finally you are not stupid or deceptive.

    If H never returns a value to P then H is not a halting
    decider; if H returns a value of 0 to main() when P halts
    then H is not a halting decider.

    H is not a halting decider; H is a simulation detector, S.

    /Flibble


    In other words you are saying the infintely nested emulation
    only excutes for a few steps and then it stops on its own.

    I am saying that your H is not a halting decider; I am saying
    that your H is just a simulation detector, S.

    /Flibble


    You are saying that you simply "don't believe in" simulating halt
    deciders.

    You haven't got a simulating halt decider, what you have got is a
    simulation detector.

    /Flibble


    It is an easily verified fact that H does correctly decide the halt
    status of its input.

    void Infinite_Loop()
    {
    HERE: goto HERE;
    }

    int main()
    {
    Output("Input_Halts = ", H0(Infinite_Loop));
    }

    _Infinite_Loop()
    [00001342](01) 55 push ebp
    [00001343](02) 8bec mov ebp,esp
    [00001345](02) ebfe jmp 00001345
    [00001347](01) 5d pop ebp
    [00001348](01) c3 ret
    Size in bytes:(0007) [00001348]

    _main()
    [00001372](01) 55 push ebp
    [00001373](02) 8bec mov ebp,esp
    [00001375](05) 6842130000 push 00001342
    [0000137a](05) e833fdffff call 000010b2
    [0000137f](03) 83c404 add esp,+04
    [00001382](01) 50 push eax
    [00001383](05) 6823040000 push 00000423
    [00001388](05) e8e5f0ffff call 00000472
    [0000138d](03) 83c408 add esp,+08
    [00001390](02) 33c0 xor eax,eax
    [00001392](01) 5d pop ebp
    [00001393](01) c3 ret
    Size in bytes:(0034) [00001393]

    machine stack stack machine assembly
    address address data code language
    ======== ======== ======== ========= =============
    [00001372][0010228f][00000000] 55 push ebp
    [00001373][0010228f][00000000] 8bec mov ebp,esp
    [00001375][0010228b][00001342] 6842130000 push 00001342 // push
    _Infinite_Loop
    [0000137a][00102287][0000137f] e833fdffff call 000010b2 // call H0

    Begin Local Halt Decider Simulation Execution Trace Stored
    at:212343 [00001342][00212333][00212337] 55 push ebp
    [00001343][00212333][00212337] 8bec mov ebp,esp
    [00001345][00212333][00212337] ebfe jmp 00001345
    [00001345][00212333][00212337] ebfe jmp 00001345
    Local Halt Decider: Infinite Loop Detected Simulation Stopped

    [0000137f][0010228f][00000000] 83c404 add esp,+04
    [00001382][0010228b][00000000] 50 push eax
    [00001383][00102287][00000423] 6823040000 push 00000423
    [00001388][00102287][00000423] e8e5f0ffff call 00000472
    Input_Halts = 0
    [0000138d][0010228f][00000000] 83c408 add esp,+08
    [00001390][0010228f][00000000] 33c0 xor eax,eax
    [00001392][00102293][00100000] 5d pop ebp
    [00001393][00102297][00000004] c3 ret
    Number of Instructions Executed(680)

    int Sum(int X, int Y)
    {
    return X + Y;
    }

    int main()
    {
    Output("Input_Halts = ", H2(Sum, 3, 4));
    }

    _Sum()
    [000012b6](01) 55 push ebp
    [000012b7](02) 8bec mov ebp,esp
    [000012b9](03) 8b4508 mov eax,[ebp+08]
    [000012bc](03) 03450c add eax,[ebp+0c]
    [000012bf](01) 5d pop ebp
    [000012c0](01) c3 ret
    Size in bytes:(0011) [000012c0]

    _main()
    [00001316](01) 55 push ebp
    [00001317](02) 8bec mov ebp,esp
    [00001319](02) 6a04 push +04
    [0000131b](02) 6a03 push +03
    [0000131d](05) 68b6120000 push 000012b6
    [00001322](05) e85ffaffff call 00000d86
    [00001327](03) 83c40c add esp,+0c
    [0000132a](01) 50 push eax
    [0000132b](05) 6807040000 push 00000407
    [00001330](05) e821f1ffff call 00000456
    [00001335](03) 83c408 add esp,+08
    [00001338](02) 33c0 xor eax,eax
    [0000133a](01) 5d pop ebp
    [0000133b](01) c3 ret
    Size in bytes:(0038) [0000133b]

    machine stack stack machine assembly
    address address data code language
    ======== ======== ======== ========= =============
    ...[00001316][001021d7][00000000] 55 push ebp
    ...[00001317][001021d7][00000000] 8bec mov ebp,esp
    ...[00001319][001021d3][00000004] 6a04 push +04
    ...[0000131b][001021cf][00000003] 6a03 push +03
    ...[0000131d][001021cb][000012b6] 68b6120000 push 000012b6
    ...[00001322][001021c7][00001327] e85ffaffff call 00000d86

    Begin Local Halt Decider Simulation Execution Trace Stored
    at:21228b ...[000012b6][00212273][00212277] 55 push
    ebp ...[000012b7][00212273][00212277] 8bec mov ebp,esp
    ...[000012b9][00212273][00212277] 8b4508 mov eax,[ebp+08]
    ...[000012bc][00212273][00212277] 03450c add eax,[ebp+0c]
    ...[000012bf][00212277][00000e54] 5d pop ebp
    ...[000012c0][0021227b][00000003] c3 ret
    ...[00001327][001021d7][00000000] 83c40c add esp,+0c
    ...[0000132a][001021d3][00000001] 50 push eax
    ...[0000132b][001021cf][00000407] 6807040000 push 00000407
    ---[00001330][001021cf][00000407] e821f1ffff call 00000456
    Input_Halts = 1
    ...[00001335][001021d7][00000000] 83c408 add esp,+08
    ...[00001338][001021d7][00000000] 33c0 xor eax,eax
    ...[0000133a][001021db][00100000] 5d pop ebp
    ...[0000133b][001021df][00000004] c3 ret
    Number of Instructions Executed(660)

    All you are showing here is that your H can decide the halt status
    of two trivial cases however you have not shown that H can decide
    the halt status of non-trivial cases.


    You said:
    "You haven't got a simulating halt decider"
    Apologize and we can move on.

    I posted four paragraphs but you ignored three of them. Lets try again.


    If you don't apologize then wee can move on.

    All you are showing here is that your H can decide the halt status of
    two trivial cases however you have not shown that H can decide the halt status of non-trivial cases.

    Publish the source code of your halt decider so we can see what classes
    of programs your H can decide.

    I am interested in deciding the halt status of programs containing non-trivial branching logic predicated on arbitrary program input.

    Crucially if your H cannot return an answer for an arbitrary
    non-halting program in finite time then it isn't a halt decider.

    /Flibble



    --
    Copyright 2022 Pete Olcott

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

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Mr Flibble on Fri Jun 10 08:33:27 2022
    XPost: comp.theory, sci.logic, sci.math

    On 6/10/2022 8:29 AM, Mr Flibble wrote:
    On Fri, 10 Jun 2022 08:27:28 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/10/2022 8:23 AM, Mr Flibble wrote:
    On Fri, 10 Jun 2022 08:05:57 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/10/2022 6:11 AM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:35:05 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 5:27 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:18:38 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 5:15 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:09:08 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 4:54 PM, Richard Damon wrote:
    On 6/9/22 5:29 PM, olcott wrote:
    On 6/9/2022 4:13 PM, Richard Damon wrote:

    On 6/9/22 5:00 PM, olcott wrote:
    On 6/9/2022 3:25 PM, Richard Damon wrote:
    On 6/9/22 4:13 PM, olcott wrote:
    On 6/9/2022 2:57 PM, Richard Damon wrote:
    On 6/9/22 3:52 PM, olcott wrote:
    On 6/9/2022 2:38 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>
    On 6/9/22 3:26 PM, olcott wrote:
    On 6/9/2022 1:12 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 6/9/22 1:55 PM, olcott wrote:
    On 6/9/2022 12:46 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 12:39:32 -0500 >>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>
    On 6/9/2022 12:28 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 12:15:24 -0500 >>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 12:06 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 12:54 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 11:34 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>
    On 6/9/22 11:47 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void P(u32 x)
    {
         if (H(x, x)) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>        HERE: goto HERE; >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>      return; >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }

    int main()
    {
         P(P); >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }

    _P()
    [000012e7](01)  55              push ebp
    [000012e8](02)  8bec            mov >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp [000012ea](03)  8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08] [000012ed](01)  50 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push eax [000012ee](03)  8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08] [000012f1](01)  51 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ecx [000012f2](05)  e880feffff >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> call 00001177 // call H [000012f7](03) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 83c408 add esp,+08 [000012fa](02)  85c0 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> test eax,eax [000012fc](02)  7402 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> jz 00001300 [000012fe](02)  ebfe >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> jmp 000012fe [00001300](01)  5d >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pop ebp [00001301](01)  c3 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ret Size in bytes:(0027) [00001301] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    _main()
    [00001307](01)  55              push ebp
    [00001308](02)  8bec            mov >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp [0000130a](05)  68e7120000 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push 000012e7 // push P [0000130f](05) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e8d3ffffff call 000012e7 // call P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001314](03) 83c404 add esp,+04 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001317](02)  33c0 xor eax,eax >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001319](01)  5d pop ebp [0000131a](01) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> c3              ret Size in bytes:(0020)
    [0000131a]

        machine   stack     stack >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine assembly address   address   data >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>     code language ========  ======== >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ======== ========= ============= >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001307][00102190][00000000] 55 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp [00001308][00102190][00000000] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8bec mov ebp,esp
    [0000130a][0010218c][000012e7] 68e7120000 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push 000012e7 // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000130f][00102188][00001314] e8d3ffffff >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> call 000012e7 // call P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e7][00102184][00102190] 55 push >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebp // enter executed P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e8][00102184][00102190] 8bec >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp
    [000012ea][00102184][00102190] 8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08]
    [000012ed][00102180][000012e7] 50 push >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> eax // push P
    [000012ee][00102180][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08]
    [000012f1][0010217c][000012e7] 51 push >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ecx // push P
    [000012f2][00102178][000012f7] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    Begin Local Halt Decider Simulation >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Execution Trace Stored >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> at:212244 [000012e7][00212230][00212234] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 55 push ebp // enter emulated P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e8][00212230][00212234] 8bec >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp
    [000012ea][00212230][00212234] 8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08]
    [000012ed][0021222c][000012e7] 50 push >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> eax      // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ee][0021222c][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08]
    [000012f1][00212228][000012e7] 51 push >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ecx // push P
    [000012f2][00212224][000012f7] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    So, by what instruction reference manual >>>>>>>>>>>>>>>>>>>>>>>>>>>>> is a call 00001177
    followedby the execution of the >>>>>>>>>>>>>>>>>>>>>>>>>>>>> instruction at 000012e7. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    Your "CPU" is broken, or emulation >>>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect.

    FAIL.
    [000012e7][0025cc58][0025cc5c] 55 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp      // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> enter emulated P
    [000012e8][0025cc58][0025cc5c] 8bec >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp
    [000012ea][0025cc58][0025cc5c] 8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08]
    [000012ed][0025cc54][000012e7] 50 push >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> eax      // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ee][0025cc54][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08]
    [000012f1][0025cc50][000012e7] 51 push >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ecx // push P
    [000012f2][0025cc4c][000012f7] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H Local >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halt Decider: Infinite Recursion >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Detected Simulation Stopped >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    It is completely obvious that when H(P,P) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly emulates >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input that it must emulate the first >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> seven instructions of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P. Because the seventh instruction of P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeats this process we >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> know with complete certainty that the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulation of P by H would never reach its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final “ret” instruction, thus never >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts.

    Problem, the 7th intruction DOESN't "Just >>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeat the procedure", >>>>>>>>>>>>>>>>>>>>>>>>>>>>> because that H always has the option to >>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort its simulation, >>>>>>>>>>>>>>>>>>>>>>>>>>>>> just like this onne did, and return to >>>>>>>>>>>>>>>>>>>>>>>>>>>>> its P and see it halt. >>>>>>>>>>>>>>>>>>>>>>>>>>>> THAT YOU ARE SIMPLY TOO STUPID TO >>>>>>>>>>>>>>>>>>>>>>>>>>>> UNDERSTAND THIS IS NO ACTUAL >>>>>>>>>>>>>>>>>>>>>>>>>>>> REBUTTAL AT ALL:

    The partial correct x86 emulation of the >>>>>>>>>>>>>>>>>>>>>>>>>>>> input to H(P,P) conclusively proves that >>>>>>>>>>>>>>>>>>>>>>>>>>>> the complete and correct x86 emulation >>>>>>>>>>>>>>>>>>>>>>>>>>>> would never stop running. >>>>>>>>>>>>>>>>>>>>>>>>>>>>

    You SAY that, but you don't answer the >>>>>>>>>>>>>>>>>>>>>>>>>>> actual questions about HOW. >>>>>>>>>>>>>>>>>>>>>>>>>>
    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND >>>>>>>>>>>>>>>>>>>>>>>>>> THIS IS NO EVIDENCE
    WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE >>>>>>>>>>>>>>>>>>>>>>>>>> THAT THE CORRECT
    PARTIAL EMULATION OF THE INPUT TO H(P,P) >>>>>>>>>>>>>>>>>>>>>>>>>> CONCLUSIVELY PROVES THAT
    THE CORRECT AND COMPLETE X86 EMULATION OF THE >>>>>>>>>>>>>>>>>>>>>>>>>> INPUT TO H(P,P)
    WOULD NEVER STOP RUNNING.

    It is completely obvious that when H(P,P) >>>>>>>>>>>>>>>>>>>>>>>>>> correctly emulates its
    input that it must emulate the first seven >>>>>>>>>>>>>>>>>>>>>>>>>> instructions of P.
    Because the seventh instruction of P repeats >>>>>>>>>>>>>>>>>>>>>>>>>> this process we know
    with complete certainty that the correct and >>>>>>>>>>>>>>>>>>>>>>>>>> complete emulation of
    P by H would never reach its final “ret” >>>>>>>>>>>>>>>>>>>>>>>>>> instruction, thus never
    halts.

    If P should have halted (i.e. no infinite >>>>>>>>>>>>>>>>>>>>>>>>> loop) then your simulation
    detector, S (not H), gets the answer wrong. >>>>>>>>>>>>>>>>>>>>>>>>> You S is NOT a halting
    decider.

    /Flibble

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND >>>>>>>>>>>>>>>>>>>>>>>> THIS IS NO ACTUAL
    REBUTTAL AT ALL.

    _P()
    [00001352](01)  55              push ebp >>>>>>>>>>>>>>>>>>>>>>>> [00001353](02)  8bec            mov ebp,esp
    [00001355](03)  8b4508          mov >>>>>>>>>>>>>>>>>>>>>>>> eax,[ebp+08] [00001358](01)  50 >>>>>>>>>>>>>>>>>>>>>>>> push eax      // push P [00001359](03)  8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>          mov ecx,[ebp+08] [0000135c](01)  51 >>>>>>>>>>>>>>>>>>>>>>>>            push ecx      // push P >>>>>>>>>>>>>>>>>>>>>>>> [0000135d](05)  e840feffff call 000011a2 // >>>>>>>>>>>>>>>>>>>>>>>> call H [00001362](03)  83c408 add esp,+08 >>>>>>>>>>>>>>>>>>>>>>>> [00001365](02)  85c0 test eax,eax >>>>>>>>>>>>>>>>>>>>>>>> [00001367](02)  7402            jz 0000136b
    [00001369](02)  ebfe            jmp 00001369
    [0000136b](01)  5d              pop ebp >>>>>>>>>>>>>>>>>>>>>>>> [0000136c](01)  c3              ret Size in
    bytes:(0027) [0000136c]

    It is completely obvious that when H(P,P) >>>>>>>>>>>>>>>>>>>>>>>> correctly emulates its
    input that it must emulate the first seven >>>>>>>>>>>>>>>>>>>>>>>> instructions of P. Because
    the seventh instruction of P repeats this >>>>>>>>>>>>>>>>>>>>>>>> process we know with
    complete certainty that the correct and >>>>>>>>>>>>>>>>>>>>>>>> complete emulation of P by H
    would never reach its final “ret” instruction, >>>>>>>>>>>>>>>>>>>>>>>> thus never halts.

    We are going around and around and around in >>>>>>>>>>>>>>>>>>>>>>> circles. I will try again:

    If you replace the opcodes "EB FE" at 00001369 >>>>>>>>>>>>>>>>>>>>>>> with the opcodes "90 90"
    then your H gets the answer wrong: P should have >>>>>>>>>>>>>>>>>>>>>>> halted.

    /Flibble


    As I already said before this is merely your >>>>>>>>>>>>>>>>>>>>>> cluelessness that when H(P,P) is invoked the >>>>>>>>>>>>>>>>>>>>>> correct x86 emulation of the input to H(P,P) >>>>>>>>>>>>>>>>>>>>>> makes and code after [0000135d] unreachable. >>>>>>>>>>>>>>>>>>>>>
    Wrong, because when that H return the value 0, it >>>>>>>>>>>>>>>>>>>>> will get there.
    Like I said people that are dumber than a box of >>>>>>>>>>>>>>>>>>>> rocks won't be able to correctly understand this. >>>>>>>>>>>>>>>>>>>>
    When H(P,P) is invoked the correctly emulated input >>>>>>>>>>>>>>>>>>>> to H(P,P) cannot possibly reach any instruction >>>>>>>>>>>>>>>>>>>> beyond [0000135d].

    So, you are defining that you H(P,P) never returns >>>>>>>>>>>>>>>>>>> because it is caught in the infinite rcursion. >>>>>>>>>>>>>>>>>>>
    Thats fine, just says it can't be the correctly >>>>>>>>>>>>>>>>>>> answering decider you claim it to be.

    I have corrected you on this too many times. >>>>>>>>>>>>>>>>>>

    How. You need to define what H(P,P) actually does. >>>>>>>>>>>>>>>>
    I have explained that too many times.

    To understand that H(P,P)==0 is correct we only need to >>>>>>>>>>>>>>>> know that H performs a correct x86 emulation of its >>>>>>>>>>>>>>>> input and then examine the execution trace.

    And a CORRECT emulation of the code will Halt if H(P,P) >>>>>>>>>>>>>>> returns 0, which it can only do if it does not actually >>>>>>>>>>>>>>> do a correct emulation

    The correctly emulated input to H(P,P) never gets past >>>>>>>>>>>>>> its machine address [0000135d].



    Only if H actually doesn't return 0. Yes, H can't
    correctly return 0 if it correctly emulates its input, >>>>>>>>>>>>> but you can't drop that requirement.

    void P(u32 x)
    {
       if (H(x, x))
         HERE: goto HERE;
       return;
    }

    int main()
    {
       Output("Input_Halts = ", H((u32)P, (u32)P)); >>>>>>>>>>>> }

    When H returns 0 it does not returns 0 to P it returns 0 to >>>>>>>>>>>> main().

    But it also return 0 to the computation P(P), maybe not the >>>>>>>>>>> copy that it is simulating, since it aborts that before it >>>>>>>>>>> get to it,

    Finally you are not stupid or deceptive.

    If H never returns a value to P then H is not a halting
    decider; if H returns a value of 0 to main() when P halts
    then H is not a halting decider.

    H is not a halting decider; H is a simulation detector, S.

    /Flibble


    In other words you are saying the infintely nested emulation
    only excutes for a few steps and then it stops on its own.

    I am saying that your H is not a halting decider; I am saying
    that your H is just a simulation detector, S.

    /Flibble


    You are saying that you simply "don't believe in" simulating halt
    deciders.

    You haven't got a simulating halt decider, what you have got is a
    simulation detector.

    /Flibble


    It is an easily verified fact that H does correctly decide the halt
    status of its input.

    void Infinite_Loop()
    {
    HERE: goto HERE;
    }

    int main()
    {
    Output("Input_Halts = ", H0(Infinite_Loop));
    }

    _Infinite_Loop()
    [00001342](01) 55 push ebp
    [00001343](02) 8bec mov ebp,esp
    [00001345](02) ebfe jmp 00001345
    [00001347](01) 5d pop ebp
    [00001348](01) c3 ret
    Size in bytes:(0007) [00001348]

    _main()
    [00001372](01) 55 push ebp
    [00001373](02) 8bec mov ebp,esp
    [00001375](05) 6842130000 push 00001342
    [0000137a](05) e833fdffff call 000010b2
    [0000137f](03) 83c404 add esp,+04
    [00001382](01) 50 push eax
    [00001383](05) 6823040000 push 00000423
    [00001388](05) e8e5f0ffff call 00000472
    [0000138d](03) 83c408 add esp,+08
    [00001390](02) 33c0 xor eax,eax
    [00001392](01) 5d pop ebp
    [00001393](01) c3 ret
    Size in bytes:(0034) [00001393]

    machine stack stack machine assembly
    address address data code language
    ======== ======== ======== ========= =============
    [00001372][0010228f][00000000] 55 push ebp
    [00001373][0010228f][00000000] 8bec mov ebp,esp
    [00001375][0010228b][00001342] 6842130000 push 00001342 // push
    _Infinite_Loop
    [0000137a][00102287][0000137f] e833fdffff call 000010b2 // call H0

    Begin Local Halt Decider Simulation Execution Trace Stored
    at:212343 [00001342][00212333][00212337] 55 push ebp
    [00001343][00212333][00212337] 8bec mov ebp,esp
    [00001345][00212333][00212337] ebfe jmp 00001345
    [00001345][00212333][00212337] ebfe jmp 00001345
    Local Halt Decider: Infinite Loop Detected Simulation Stopped

    [0000137f][0010228f][00000000] 83c404 add esp,+04
    [00001382][0010228b][00000000] 50 push eax
    [00001383][00102287][00000423] 6823040000 push 00000423
    [00001388][00102287][00000423] e8e5f0ffff call 00000472
    Input_Halts = 0
    [0000138d][0010228f][00000000] 83c408 add esp,+08
    [00001390][0010228f][00000000] 33c0 xor eax,eax
    [00001392][00102293][00100000] 5d pop ebp
    [00001393][00102297][00000004] c3 ret
    Number of Instructions Executed(680)

    int Sum(int X, int Y)
    {
    return X + Y;
    }

    int main()
    {
    Output("Input_Halts = ", H2(Sum, 3, 4));
    }

    _Sum()
    [000012b6](01) 55 push ebp
    [000012b7](02) 8bec mov ebp,esp
    [000012b9](03) 8b4508 mov eax,[ebp+08]
    [000012bc](03) 03450c add eax,[ebp+0c]
    [000012bf](01) 5d pop ebp
    [000012c0](01) c3 ret
    Size in bytes:(0011) [000012c0]

    _main()
    [00001316](01) 55 push ebp
    [00001317](02) 8bec mov ebp,esp
    [00001319](02) 6a04 push +04
    [0000131b](02) 6a03 push +03
    [0000131d](05) 68b6120000 push 000012b6
    [00001322](05) e85ffaffff call 00000d86
    [00001327](03) 83c40c add esp,+0c
    [0000132a](01) 50 push eax
    [0000132b](05) 6807040000 push 00000407
    [00001330](05) e821f1ffff call 00000456
    [00001335](03) 83c408 add esp,+08
    [00001338](02) 33c0 xor eax,eax
    [0000133a](01) 5d pop ebp
    [0000133b](01) c3 ret
    Size in bytes:(0038) [0000133b]

    machine stack stack machine assembly
    address address data code language
    ======== ======== ======== ========= =============
    ...[00001316][001021d7][00000000] 55 push ebp
    ...[00001317][001021d7][00000000] 8bec mov ebp,esp
    ...[00001319][001021d3][00000004] 6a04 push +04
    ...[0000131b][001021cf][00000003] 6a03 push +03
    ...[0000131d][001021cb][000012b6] 68b6120000 push 000012b6
    ...[00001322][001021c7][00001327] e85ffaffff call 00000d86

    Begin Local Halt Decider Simulation Execution Trace Stored
    at:21228b ...[000012b6][00212273][00212277] 55 push
    ebp ...[000012b7][00212273][00212277] 8bec mov ebp,esp
    ...[000012b9][00212273][00212277] 8b4508 mov eax,[ebp+08]
    ...[000012bc][00212273][00212277] 03450c add eax,[ebp+0c]
    ...[000012bf][00212277][00000e54] 5d pop ebp
    ...[000012c0][0021227b][00000003] c3 ret
    ...[00001327][001021d7][00000000] 83c40c add esp,+0c
    ...[0000132a][001021d3][00000001] 50 push eax
    ...[0000132b][001021cf][00000407] 6807040000 push 00000407
    ---[00001330][001021cf][00000407] e821f1ffff call 00000456
    Input_Halts = 1
    ...[00001335][001021d7][00000000] 83c408 add esp,+08
    ...[00001338][001021d7][00000000] 33c0 xor eax,eax
    ...[0000133a][001021db][00100000] 5d pop ebp
    ...[0000133b][001021df][00000004] c3 ret
    Number of Instructions Executed(660)

    All you are showing here is that your H can decide the halt status
    of two trivial cases however you have not shown that H can decide
    the halt status of non-trivial cases.


    You said:
    "You haven't got a simulating halt decider"
    Apologize and we can move on.

    I posted four paragraphs but you ignored three of them. Lets try again.


    IF YOU DON'T APOLOGIZE THEN WE CANNOT MOVE ON !!!

    All you are showing here is that your H can decide the halt status of
    two trivial cases however you have not shown that H can decide the halt status of non-trivial cases.

    Publish the source code of your halt decider so we can see what classes
    of programs your H can decide.

    I am interested in deciding the halt status of programs containing non-trivial branching logic predicated on arbitrary program input.

    Crucially if your H cannot return an answer for an arbitrary
    non-halting program in finite time then it isn't a halt decider.

    /Flibble



    --
    Copyright 2022 Pete Olcott

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

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Fri Jun 10 09:34:53 2022
    XPost: comp.theory, sci.logic, sci.math

    On 6/10/22 9:05 AM, olcott wrote:
    On 6/10/2022 6:11 AM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:35:05 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 5:27 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:18:38 -0500
    olcott <NoOne@NoWhere.com> wrote:
    On 6/9/2022 5:15 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:09:08 -0500
    olcott <NoOne@NoWhere.com> wrote:
    On 6/9/2022 4:54 PM, Richard Damon wrote:
    On 6/9/22 5:29 PM, olcott wrote:
    On 6/9/2022 4:13 PM, Richard Damon wrote:

    On 6/9/22 5:00 PM, olcott wrote:
    On 6/9/2022 3:25 PM, Richard Damon wrote:
    On 6/9/22 4:13 PM, olcott wrote:
    On 6/9/2022 2:57 PM, Richard Damon wrote:
    On 6/9/22 3:52 PM, olcott wrote:
    On 6/9/2022 2:38 PM, Richard Damon wrote:

    On 6/9/22 3:26 PM, olcott wrote:
    On 6/9/2022 1:12 PM, Richard Damon wrote:
    On 6/9/22 1:55 PM, olcott wrote:
    On 6/9/2022 12:46 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 12:39:32 -0500
    olcott <NoOne@NoWhere.com> wrote:
    On 6/9/2022 12:28 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 12:15:24 -0500
    olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 12:06 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 12:54 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 11:34 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 11:47 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> void P(u32 x)
    {
            if (H(x, x)) >>>>>>>>>>>>>>>>>>>>>>>>>>>           HERE: goto HERE; >>>>>>>>>>>>>>>>>>>>>>>>>>>         return;
    }

    int main()
    {
            P(P);
    }

    _P()
    [000012e7](01)  55              push ebp
    [000012e8](02)  8bec            mov ebp,esp
    [000012ea](03)  8b4508          mov >>>>>>>>>>>>>>>>>>>>>>>>>>> eax,[ebp+08] [000012ed](01)  50 >>>>>>>>>>>>>>>>>>>>>>>>>>> push eax [000012ee](03)  8b4d08          mov
    ecx,[ebp+08] [000012f1](01)  51 >>>>>>>>>>>>>>>>>>>>>>>>>>> push ecx [000012f2](05)  e880feffff      call >>>>>>>>>>>>>>>>>>>>>>>>>>> 00001177 // call H [000012f7](03)  83c408 >>>>>>>>>>>>>>>>>>>>>>>>>>>       add esp,+08 [000012fa](02)  85c0 >>>>>>>>>>>>>>>>>>>>>>>>>>>    test eax,eax [000012fc](02)  7402 >>>>>>>>>>>>>>>>>>>>>>>>>>> jz 00001300 [000012fe](02)  ebfe >>>>>>>>>>>>>>>>>>>>>>>>>>> jmp 000012fe [00001300](01)  5d >>>>>>>>>>>>>>>>>>>>>>>>>>> pop ebp [00001301](01)  c3              ret
    Size in bytes:(0027) [00001301] >>>>>>>>>>>>>>>>>>>>>>>>>>>
    _main()
    [00001307](01)  55              push ebp
    [00001308](02)  8bec            mov ebp,esp
    [0000130a](05)  68e7120000      push 000012e7 >>>>>>>>>>>>>>>>>>>>>>>>>>> // push P [0000130f](05)  e8d3ffffff >>>>>>>>>>>>>>>>>>>>>>>>>>> call 000012e7 // call P [00001314](03) >>>>>>>>>>>>>>>>>>>>>>>>>>> 83c404 add esp,+04 [00001317](02)  33c0 >>>>>>>>>>>>>>>>>>>>>>>>>>> xor eax,eax [00001319](01)  5d >>>>>>>>>>>>>>>>>>>>>>>>>>> pop ebp [0000131a](01)  c3              ret
    Size in bytes:(0020) [0000131a] >>>>>>>>>>>>>>>>>>>>>>>>>>>
           machine   stack     stack     machine
    assembly address   address   data      code
        language ========  ========  ======== >>>>>>>>>>>>>>>>>>>>>>>>>>> ========= =============
    [00001307][00102190][00000000] 55 >>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp [00001308][00102190][00000000] 8bec >>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp [0000130a][0010218c][000012e7] >>>>>>>>>>>>>>>>>>>>>>>>>>> 68e7120000 push 000012e7 // >>>>>>>>>>>>>>>>>>>>>>>>>>> push P [0000130f][00102188][00001314] >>>>>>>>>>>>>>>>>>>>>>>>>>> e8d3ffffff call 000012e7 >>>>>>>>>>>>>>>>>>>>>>>>>>> // call P [000012e7][00102184][00102190] 55 >>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp // enter executed P >>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e8][00102184][00102190] 8bec       mov >>>>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp [000012ea][00102184][00102190] 8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>>>     mov eax,[ebp+08]
    [000012ed][00102180][000012e7] 50 >>>>>>>>>>>>>>>>>>>>>>>>>>> push eax      //
    push P [000012ee][00102180][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08]
    [000012f1][0010217c][000012e7] 51 push ecx >>>>>>>>>>>>>>>>>>>>>>>>>>>     // push P [000012f2][00102178][000012f7] >>>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H >>>>>>>>>>>>>>>>>>>>>>>>>>>
    Begin Local Halt Decider Simulation >>>>>>>>>>>>>>>>>>>>>>>>>>> Execution Trace Stored
    at:212244 [000012e7][00212230][00212234] 55 >>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp // enter emulated P >>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e8][00212230][00212234] 8bec >>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp [000012ea][00212230][00212234] >>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4508 mov eax,[ebp+08]
    [000012ed][0021222c][000012e7] 50 >>>>>>>>>>>>>>>>>>>>>>>>>>> push eax      //
    push P [000012ee][0021222c][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>>>     mov ecx,[ebp+08]
    [000012f1][00212228][000012e7] 51 push ecx >>>>>>>>>>>>>>>>>>>>>>>>>>>    // push P [000012f2][00212224][000012f7] >>>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H >>>>>>>>>>>>>>>>>>>>>>>>>>
    So, by what instruction reference manual is a >>>>>>>>>>>>>>>>>>>>>>>>>> call 00001177
    followedby the execution of the instruction at >>>>>>>>>>>>>>>>>>>>>>>>>> 000012e7.

    Your "CPU" is broken, or emulation incorrect. >>>>>>>>>>>>>>>>>>>>>>>>>>
    FAIL.
    [000012e7][0025cc58][0025cc5c] 55 >>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp      //
    enter emulated P
    [000012e8][0025cc58][0025cc5c] 8bec >>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp [000012ea][0025cc58][0025cc5c] >>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4508 mov eax,[ebp+08]
    [000012ed][0025cc54][000012e7] 50 >>>>>>>>>>>>>>>>>>>>>>>>>>> push eax      //
    push P [000012ee][0025cc54][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>>>     mov ecx,[ebp+08]
    [000012f1][0025cc50][000012e7] 51 push ecx >>>>>>>>>>>>>>>>>>>>>>>>>>>    // push P [000012f2][0025cc4c][000012f7] >>>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H Local Halt >>>>>>>>>>>>>>>>>>>>>>>>>>> Decider: Infinite Recursion >>>>>>>>>>>>>>>>>>>>>>>>>>> Detected Simulation Stopped >>>>>>>>>>>>>>>>>>>>>>>>>>>
    It is completely obvious that when H(P,P) >>>>>>>>>>>>>>>>>>>>>>>>>>> correctly emulates
    its input that it must emulate the first >>>>>>>>>>>>>>>>>>>>>>>>>>> seven instructions of
    P. Because the seventh instruction of P >>>>>>>>>>>>>>>>>>>>>>>>>>> repeats this process we
    know with complete certainty that the correct >>>>>>>>>>>>>>>>>>>>>>>>>>> and complete
    emulation of P by H would never reach its >>>>>>>>>>>>>>>>>>>>>>>>>>> final “ret” instruction, thus never halts. >>>>>>>>>>>>>>>>>>>>>>>>>>
    Problem, the 7th intruction DOESN't "Just >>>>>>>>>>>>>>>>>>>>>>>>>> repeat the procedure",
    because that H always has the option to abort >>>>>>>>>>>>>>>>>>>>>>>>>> its simulation,
    just like this onne did, and return to its P >>>>>>>>>>>>>>>>>>>>>>>>>> and see it halt.
    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND >>>>>>>>>>>>>>>>>>>>>>>>> THIS IS NO ACTUAL
    REBUTTAL AT ALL:

    The partial correct x86 emulation of the input >>>>>>>>>>>>>>>>>>>>>>>>> to H(P,P) conclusively proves that the >>>>>>>>>>>>>>>>>>>>>>>>> complete and correct x86 emulation >>>>>>>>>>>>>>>>>>>>>>>>> would never stop running.

    You SAY that, but you don't answer the actual >>>>>>>>>>>>>>>>>>>>>>>> questions about HOW.

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS >>>>>>>>>>>>>>>>>>>>>>> IS NO EVIDENCE
    WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE THAT >>>>>>>>>>>>>>>>>>>>>>> THE CORRECT
    PARTIAL EMULATION OF THE INPUT TO H(P,P) >>>>>>>>>>>>>>>>>>>>>>> CONCLUSIVELY PROVES THAT
    THE CORRECT AND COMPLETE X86 EMULATION OF THE >>>>>>>>>>>>>>>>>>>>>>> INPUT TO H(P,P)
    WOULD NEVER STOP RUNNING.

    It is completely obvious that when H(P,P) >>>>>>>>>>>>>>>>>>>>>>> correctly emulates its
    input that it must emulate the first seven >>>>>>>>>>>>>>>>>>>>>>> instructions of P.
    Because the seventh instruction of P repeats this >>>>>>>>>>>>>>>>>>>>>>> process we know
    with complete certainty that the correct and >>>>>>>>>>>>>>>>>>>>>>> complete emulation of
    P by H would never reach its final “ret” >>>>>>>>>>>>>>>>>>>>>>> instruction, thus never
    halts.

    If P should have halted (i.e. no infinite loop) >>>>>>>>>>>>>>>>>>>>>> then your simulation
    detector, S (not H), gets the answer wrong.  You S >>>>>>>>>>>>>>>>>>>>>> is NOT a halting
    decider.

    /Flibble

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS >>>>>>>>>>>>>>>>>>>>> IS NO ACTUAL
    REBUTTAL AT ALL.

    _P()
    [00001352](01)  55              push ebp >>>>>>>>>>>>>>>>>>>>> [00001353](02)  8bec            mov ebp,esp >>>>>>>>>>>>>>>>>>>>> [00001355](03)  8b4508          mov eax,[ebp+08]
    [00001358](01)  50              push eax      //
    push P [00001359](03)  8b4d08          mov >>>>>>>>>>>>>>>>>>>>> ecx,[ebp+08] [0000135c](01)  51              push
    ecx      // push P [0000135d](05)  e840feffff >>>>>>>>>>>>>>>>>>>>> call 000011a2 // call H [00001362](03)  83c408 >>>>>>>>>>>>>>>>>>>>>      add esp,+08 [00001365](02)  85c0 >>>>>>>>>>>>>>>>>>>>> test eax,eax [00001367](02)  7402            jz
    0000136b [00001369](02)  ebfe            jmp >>>>>>>>>>>>>>>>>>>>> 00001369 [0000136b](01)  5d              pop ebp
    [0000136c](01)  c3              ret >>>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]

    It is completely obvious that when H(P,P) correctly >>>>>>>>>>>>>>>>>>>>> emulates its
    input that it must emulate the first seven >>>>>>>>>>>>>>>>>>>>> instructions of P. Because
    the seventh instruction of P repeats this process >>>>>>>>>>>>>>>>>>>>> we know with
    complete certainty that the correct and complete >>>>>>>>>>>>>>>>>>>>> emulation of P by H
    would never reach its final “ret” instruction, thus >>>>>>>>>>>>>>>>>>>>> never halts.

    We are going around and around and around in >>>>>>>>>>>>>>>>>>>> circles. I will try again:

    If you replace the opcodes "EB FE" at 00001369 with >>>>>>>>>>>>>>>>>>>> the opcodes "90 90"
    then your H gets the answer wrong: P should have >>>>>>>>>>>>>>>>>>>> halted.

    /Flibble

    As I already said before this is merely your >>>>>>>>>>>>>>>>>>> cluelessness that when H(P,P) is invoked the correct >>>>>>>>>>>>>>>>>>> x86 emulation of the input to H(P,P) makes and code >>>>>>>>>>>>>>>>>>> after [0000135d] unreachable.

    Wrong, because when that H return the value 0, it will >>>>>>>>>>>>>>>>>> get there.
    Like I said people that are dumber than a box of rocks >>>>>>>>>>>>>>>>> won't be able to correctly understand this.

    When H(P,P) is invoked the correctly emulated input to >>>>>>>>>>>>>>>>> H(P,P) cannot possibly reach any instruction beyond >>>>>>>>>>>>>>>>> [0000135d].

    So, you are defining that you H(P,P) never returns >>>>>>>>>>>>>>>> because it is caught in the infinite rcursion. >>>>>>>>>>>>>>>>
    Thats fine, just says it can't be the correctly >>>>>>>>>>>>>>>> answering decider you claim it to be.

    I have corrected you on this too many times.

    How. You need to define what H(P,P) actually does.

    I have explained that too many times.

    To understand that H(P,P)==0 is correct we only need to >>>>>>>>>>>>> know that H performs a correct x86 emulation of its input >>>>>>>>>>>>> and then examine the execution trace.

    And a CORRECT emulation of the code will Halt if H(P,P) >>>>>>>>>>>> returns 0, which it can only do if it does not actually do a >>>>>>>>>>>> correct emulation

    The correctly emulated input to H(P,P) never gets past its >>>>>>>>>>> machine address [0000135d].


    Only if H actually doesn't return 0. Yes, H can't correctly >>>>>>>>>> return 0 if it correctly emulates its input, but you can't >>>>>>>>>> drop that requirement.

    void P(u32 x)
    {
          if (H(x, x))
            HERE: goto HERE;
          return;
    }

    int main()
    {
          Output("Input_Halts = ", H((u32)P, (u32)P));
    }

    When H returns 0 it does not returns 0 to P it returns 0 to
    main().

    But it also return 0 to the computation P(P), maybe not the copy >>>>>>>> that it is simulating, since it aborts that before it get to
    it,

    Finally you are not stupid or deceptive.

    If H never returns a value to P then H is not a halting decider;
    if H returns a value of 0 to main() when P halts then H is not a
    halting decider.

    H is not a halting decider; H is a simulation detector, S.

    /Flibble

    In other words you are saying the infintely nested emulation only
    excutes for a few steps and then it stops on its own.
    I am saying that your H is not a halting decider; I am saying that
    your H is just a simulation detector, S.

    /Flibble

    You are saying that you simply "don't believe in" simulating halt
    deciders.
    You haven't got a simulating halt decider, what you have got is a
    simulation detector.

    /Flibble


    It is an easily verified fact that H does correctly decide the halt
    status of its input.

    No, because is is shown that P(P) Halts, and thus H(P,P) is wrong.

    For a Halt Decider, the ONLY behavior of "the input" that matters is
    what the computation it represents does when independently run.

    The real problem seems more to be that H doesn't actually exist as
    actual Computation in your system (it uses features that aren't
    available for other computations)


    void Infinite_Loop()
    {
      HERE: goto HERE;
    }

    int main()
    {
      Output("Input_Halts = ", H0(Infinite_Loop));
    }

    _Infinite_Loop()
    [00001342](01)  55              push ebp
    [00001343](02)  8bec            mov ebp,esp
    [00001345](02)  ebfe            jmp 00001345
    [00001347](01)  5d              pop ebp
    [00001348](01)  c3              ret
    Size in bytes:(0007) [00001348]

    _main()
    [00001372](01)  55              push ebp
    [00001373](02)  8bec            mov ebp,esp
    [00001375](05)  6842130000      push 00001342
    [0000137a](05)  e833fdffff      call 000010b2
    [0000137f](03)  83c404          add esp,+04
    [00001382](01)  50              push eax
    [00001383](05)  6823040000      push 00000423
    [00001388](05)  e8e5f0ffff      call 00000472
    [0000138d](03)  83c408          add esp,+08
    [00001390](02)  33c0            xor eax,eax
    [00001392](01)  5d              pop ebp
    [00001393](01)  c3              ret
    Size in bytes:(0034) [00001393]

     machine   stack     stack     machine    assembly
     address   address   data      code       language
     ========  ========  ========  =========  ============= [00001372][0010228f][00000000] 55         push ebp [00001373][0010228f][00000000] 8bec       mov ebp,esp [00001375][0010228b][00001342] 6842130000 push 00001342 // push _Infinite_Loop
    [0000137a][00102287][0000137f] e833fdffff call 000010b2 // call H0

    Begin Local Halt Decider Simulation   Execution Trace Stored at:212343 [00001342][00212333][00212337] 55         push ebp [00001343][00212333][00212337] 8bec       mov ebp,esp [00001345][00212333][00212337] ebfe       jmp 00001345 [00001345][00212333][00212337] ebfe       jmp 00001345
    Local Halt Decider: Infinite Loop Detected Simulation Stopped

    [0000137f][0010228f][00000000] 83c404     add esp,+04 [00001382][0010228b][00000000] 50         push eax [00001383][00102287][00000423] 6823040000 push 00000423 [00001388][00102287][00000423] e8e5f0ffff call 00000472
    Input_Halts = 0
    [0000138d][0010228f][00000000] 83c408     add esp,+08 [00001390][0010228f][00000000] 33c0       xor eax,eax [00001392][00102293][00100000] 5d         pop ebp [00001393][00102297][00000004] c3         ret
    Number of Instructions Executed(680)

    int Sum(int X, int Y)
    {
      return X + Y;
    }

    int main()
    {
      Output("Input_Halts = ", H2(Sum, 3, 4));
    }

    _Sum()
    [000012b6](01)  55              push ebp
    [000012b7](02)  8bec            mov ebp,esp
    [000012b9](03)  8b4508          mov eax,[ebp+08]
    [000012bc](03)  03450c          add eax,[ebp+0c]
    [000012bf](01)  5d              pop ebp
    [000012c0](01)  c3              ret
    Size in bytes:(0011) [000012c0]

    _main()
    [00001316](01)  55              push ebp
    [00001317](02)  8bec            mov ebp,esp
    [00001319](02)  6a04            push +04
    [0000131b](02)  6a03            push +03
    [0000131d](05)  68b6120000      push 000012b6
    [00001322](05)  e85ffaffff      call 00000d86
    [00001327](03)  83c40c          add esp,+0c
    [0000132a](01)  50              push eax
    [0000132b](05)  6807040000      push 00000407
    [00001330](05)  e821f1ffff      call 00000456
    [00001335](03)  83c408          add esp,+08
    [00001338](02)  33c0            xor eax,eax
    [0000133a](01)  5d              pop ebp
    [0000133b](01)  c3              ret
    Size in bytes:(0038) [0000133b]

     machine   stack     stack     machine    assembly
     address   address   data      code       language
     ========  ========  ========  =========  ============= ...[00001316][001021d7][00000000] 55              push ebp ...[00001317][001021d7][00000000] 8bec            mov ebp,esp ...[00001319][001021d3][00000004] 6a04            push +04 ...[0000131b][001021cf][00000003] 6a03            push +03 ...[0000131d][001021cb][000012b6] 68b6120000      push 000012b6 ...[00001322][001021c7][00001327] e85ffaffff      call 00000d86

    Begin Local Halt Decider Simulation   Execution Trace Stored at:21228b ...[000012b6][00212273][00212277] 55              push ebp ...[000012b7][00212273][00212277] 8bec            mov ebp,esp ...[000012b9][00212273][00212277] 8b4508          mov eax,[ebp+08] ...[000012bc][00212273][00212277] 03450c          add eax,[ebp+0c] ...[000012bf][00212277][00000e54] 5d              pop ebp ...[000012c0][0021227b][00000003] c3              ret ...[00001327][001021d7][00000000] 83c40c          add esp,+0c ...[0000132a][001021d3][00000001] 50              push eax ...[0000132b][001021cf][00000407] 6807040000      push 00000407 ---[00001330][001021cf][00000407] e821f1ffff      call 00000456 Input_Halts = 1
    ...[00001335][001021d7][00000000] 83c408          add esp,+08 ...[00001338][001021d7][00000000] 33c0            xor eax,eax ...[0000133a][001021db][00100000] 5d              pop ebp ...[0000133b][001021df][00000004] c3              ret
    Number of Instructions Executed(660)




    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Mr Flibble on Fri Jun 10 08:43:48 2022
    XPost: comp.theory, sci.logic, sci.math

    On 6/10/2022 8:35 AM, Mr Flibble wrote:
    On Fri, 10 Jun 2022 08:33:27 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/10/2022 8:29 AM, Mr Flibble wrote:
    On Fri, 10 Jun 2022 08:27:28 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/10/2022 8:23 AM, Mr Flibble wrote:
    On Fri, 10 Jun 2022 08:05:57 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/10/2022 6:11 AM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:35:05 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 5:27 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:18:38 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 5:15 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:09:08 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 4:54 PM, Richard Damon wrote:
    On 6/9/22 5:29 PM, olcott wrote:
    On 6/9/2022 4:13 PM, Richard Damon wrote:

    On 6/9/22 5:00 PM, olcott wrote:
    On 6/9/2022 3:25 PM, Richard Damon wrote:
    On 6/9/22 4:13 PM, olcott wrote:
    On 6/9/2022 2:57 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 6/9/22 3:52 PM, olcott wrote:
    On 6/9/2022 2:38 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>
    On 6/9/22 3:26 PM, olcott wrote:
    On 6/9/2022 1:12 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 1:55 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 12:46 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 12:39:32 -0500 >>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>
    On 6/9/2022 12:28 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 12:15:24 -0500 >>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 12:06 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>
    On 6/9/22 12:54 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 11:34 AM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
    On 6/9/22 11:47 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void P(u32 x)
    {
         if (H(x, x)) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>        HERE: goto HERE; >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>      return; >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }

    int main()
    {
         P(P); >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }

    _P()
    [000012e7](01)  55              push
    ebp [000012e8](02)  8bec            mov
    ebp,esp [000012ea](03)  8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08] [000012ed](01)  50 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push eax [000012ee](03)  8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08] [000012f1](01)  51 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ecx [000012f2](05)  e880feffff >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> call 00001177 // call H [000012f7](03) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 83c408 add esp,+08 [000012fa](02)  85c0 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> test eax,eax [000012fc](02)  7402 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> jz 00001300 [000012fe](02)  ebfe >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> jmp 000012fe [00001300](01)  5d >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pop ebp [00001301](01)  c3 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ret Size in bytes:(0027) [00001301] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    _main()
    [00001307](01)  55              push
    ebp [00001308](02)  8bec            mov
    ebp,esp [0000130a](05)  68e7120000 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push 000012e7 // push P [0000130f](05) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e8d3ffffff call 000012e7 // call P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001314](03) 83c404 add esp,+04 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001317](02)  33c0 xor eax,eax >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001319](01)  5d pop ebp >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000131a](01) c3              ret
    Size in bytes:(0020) [0000131a] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
        machine   stack     stack >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine assembly address   address >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> data code language ========  ======== >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ======== ========= ============= >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001307][00102190][00000000] 55 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp [00001308][00102190][00000000] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8bec mov ebp,esp >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000130a][0010218c][000012e7] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 68e7120000 push 000012e7 // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000130f][00102188][00001314] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e8d3ffffff call 000012e7 // call P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e7][00102184][00102190] 55 push >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebp // enter executed P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e8][00102184][00102190] 8bec >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp
    [000012ea][00102184][00102190] 8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ed][00102180][000012e7] 50 push >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> eax // push P
    [000012ee][00102180][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f1][0010217c][000012e7] 51 push >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ecx // push P
    [000012f2][00102178][000012f7] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    Begin Local Halt Decider Simulation >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Execution Trace Stored >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> at:212244
    [000012e7][00212230][00212234] 55 push >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebp // enter emulated P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e8][00212230][00212234] 8bec >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp
    [000012ea][00212230][00212234] 8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ed][0021222c][000012e7] 50 push >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> eax      // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ee][0021222c][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f1][00212228][000012e7] 51 push >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ecx // push P
    [000012f2][00212224][000012f7] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    So, by what instruction reference manual >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is a call 00001177 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> followedby the execution of the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instruction at 000012e7. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    Your "CPU" is broken, or emulation >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect.

    FAIL.
    [000012e7][0025cc58][0025cc5c] 55 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp      // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> enter emulated P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e8][0025cc58][0025cc5c] 8bec >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp
    [000012ea][0025cc58][0025cc5c] 8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ed][0025cc54][000012e7] 50 push >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> eax      // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ee][0025cc54][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f1][0025cc50][000012e7] 51 push >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ecx // push P
    [000012f2][0025cc4c][000012f7] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Local Halt Decider: Infinite Recursion >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Detected Simulation Stopped >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    It is completely obvious that when >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) correctly emulates >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input that it must emulate the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> first seven instructions of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P. Because the seventh instruction of P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeats this process we >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> know with complete certainty that the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulation of P by H would never reach >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its final “ret” instruction, thus never >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts.

    Problem, the 7th intruction DOESN't >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "Just repeat the procedure", >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because that H always has the option to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort its simulation, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just like this onne did, and return to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its P and see it halt. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THAT YOU ARE SIMPLY TOO STUPID TO >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UNDERSTAND THIS IS NO ACTUAL >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> REBUTTAL AT ALL:

    The partial correct x86 emulation of the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to H(P,P) conclusively proves that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the complete and correct x86 emulation >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would never stop running. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

    You SAY that, but you don't answer the >>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual questions about HOW. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
    THAT YOU ARE SIMPLY TOO STUPID TO >>>>>>>>>>>>>>>>>>>>>>>>>>>> UNDERSTAND THIS IS NO EVIDENCE >>>>>>>>>>>>>>>>>>>>>>>>>>>> WHAT-SO-EVER THAT I DID NOT COMPLETELY >>>>>>>>>>>>>>>>>>>>>>>>>>>> PROVE THAT THE CORRECT >>>>>>>>>>>>>>>>>>>>>>>>>>>> PARTIAL EMULATION OF THE INPUT TO H(P,P) >>>>>>>>>>>>>>>>>>>>>>>>>>>> CONCLUSIVELY PROVES THAT >>>>>>>>>>>>>>>>>>>>>>>>>>>> THE CORRECT AND COMPLETE X86 EMULATION OF >>>>>>>>>>>>>>>>>>>>>>>>>>>> THE INPUT TO H(P,P)
    WOULD NEVER STOP RUNNING. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
    It is completely obvious that when H(P,P) >>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly emulates its >>>>>>>>>>>>>>>>>>>>>>>>>>>> input that it must emulate the first seven >>>>>>>>>>>>>>>>>>>>>>>>>>>> instructions of P.
    Because the seventh instruction of P >>>>>>>>>>>>>>>>>>>>>>>>>>>> repeats this process we know >>>>>>>>>>>>>>>>>>>>>>>>>>>> with complete certainty that the correct >>>>>>>>>>>>>>>>>>>>>>>>>>>> and complete emulation of >>>>>>>>>>>>>>>>>>>>>>>>>>>> P by H would never reach its final “ret” >>>>>>>>>>>>>>>>>>>>>>>>>>>> instruction, thus never >>>>>>>>>>>>>>>>>>>>>>>>>>>> halts.

    If P should have halted (i.e. no infinite >>>>>>>>>>>>>>>>>>>>>>>>>>> loop) then your simulation >>>>>>>>>>>>>>>>>>>>>>>>>>> detector, S (not H), gets the answer wrong. >>>>>>>>>>>>>>>>>>>>>>>>>>> You S is NOT a halting
    decider.

    /Flibble

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND >>>>>>>>>>>>>>>>>>>>>>>>>> THIS IS NO ACTUAL
    REBUTTAL AT ALL.

    _P()
    [00001352](01)  55              push ebp
    [00001353](02)  8bec            mov ebp,esp
    [00001355](03)  8b4508          mov >>>>>>>>>>>>>>>>>>>>>>>>>> eax,[ebp+08] [00001358](01)  50 >>>>>>>>>>>>>>>>>>>>>>>>>> push eax      // push P [00001359](03) >>>>>>>>>>>>>>>>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08] [0000135c](01)  51 >>>>>>>>>>>>>>>>>>>>>>>>>>            push ecx      // push P >>>>>>>>>>>>>>>>>>>>>>>>>> [0000135d](05)  e840feffff call 000011a2 // >>>>>>>>>>>>>>>>>>>>>>>>>> call H [00001362](03)  83c408 add esp,+08 >>>>>>>>>>>>>>>>>>>>>>>>>> [00001365](02)  85c0 test eax,eax >>>>>>>>>>>>>>>>>>>>>>>>>> [00001367](02)  7402            jz 0000136b
    [00001369](02)  ebfe            jmp 00001369
    [0000136b](01)  5d              pop ebp
    [0000136c](01)  c3              ret Size in
    bytes:(0027) [0000136c]

    It is completely obvious that when H(P,P) >>>>>>>>>>>>>>>>>>>>>>>>>> correctly emulates its
    input that it must emulate the first seven >>>>>>>>>>>>>>>>>>>>>>>>>> instructions of P. Because >>>>>>>>>>>>>>>>>>>>>>>>>> the seventh instruction of P repeats this >>>>>>>>>>>>>>>>>>>>>>>>>> process we know with
    complete certainty that the correct and >>>>>>>>>>>>>>>>>>>>>>>>>> complete emulation of P by H >>>>>>>>>>>>>>>>>>>>>>>>>> would never reach its final “ret” >>>>>>>>>>>>>>>>>>>>>>>>>> instruction, thus never halts. >>>>>>>>>>>>>>>>>>>>>>>>>
    We are going around and around and around in >>>>>>>>>>>>>>>>>>>>>>>>> circles. I will try again:

    If you replace the opcodes "EB FE" at 00001369 >>>>>>>>>>>>>>>>>>>>>>>>> with the opcodes "90 90"
    then your H gets the answer wrong: P should >>>>>>>>>>>>>>>>>>>>>>>>> have halted.

    /Flibble


    As I already said before this is merely your >>>>>>>>>>>>>>>>>>>>>>>> cluelessness that when H(P,P) is invoked the >>>>>>>>>>>>>>>>>>>>>>>> correct x86 emulation of the input to H(P,P) >>>>>>>>>>>>>>>>>>>>>>>> makes and code after [0000135d] unreachable. >>>>>>>>>>>>>>>>>>>>>>>
    Wrong, because when that H return the value 0, >>>>>>>>>>>>>>>>>>>>>>> it will get there.
    Like I said people that are dumber than a box of >>>>>>>>>>>>>>>>>>>>>> rocks won't be able to correctly understand this. >>>>>>>>>>>>>>>>>>>>>>
    When H(P,P) is invoked the correctly emulated >>>>>>>>>>>>>>>>>>>>>> input to H(P,P) cannot possibly reach any >>>>>>>>>>>>>>>>>>>>>> instruction beyond [0000135d].

    So, you are defining that you H(P,P) never returns >>>>>>>>>>>>>>>>>>>>> because it is caught in the infinite rcursion. >>>>>>>>>>>>>>>>>>>>>
    Thats fine, just says it can't be the correctly >>>>>>>>>>>>>>>>>>>>> answering decider you claim it to be. >>>>>>>>>>>>>>>>>>>>
    I have corrected you on this too many times. >>>>>>>>>>>>>>>>>>>>

    How. You need to define what H(P,P) actually does. >>>>>>>>>>>>>>>>>>
    I have explained that too many times.

    To understand that H(P,P)==0 is correct we only need >>>>>>>>>>>>>>>>>> to know that H performs a correct x86 emulation of >>>>>>>>>>>>>>>>>> its input and then examine the execution trace. >>>>>>>>>>>>>>>>>
    And a CORRECT emulation of the code will Halt if >>>>>>>>>>>>>>>>> H(P,P) returns 0, which it can only do if it does not >>>>>>>>>>>>>>>>> actually do a correct emulation

    The correctly emulated input to H(P,P) never gets past >>>>>>>>>>>>>>>> its machine address [0000135d].



    Only if H actually doesn't return 0. Yes, H can't >>>>>>>>>>>>>>> correctly return 0 if it correctly emulates its input, >>>>>>>>>>>>>>> but you can't drop that requirement.

    void P(u32 x)
    {
       if (H(x, x))
         HERE: goto HERE;
       return;
    }

    int main()
    {
       Output("Input_Halts = ", H((u32)P, (u32)P)); >>>>>>>>>>>>>> }

    When H returns 0 it does not returns 0 to P it returns 0 >>>>>>>>>>>>>> to main().

    But it also return 0 to the computation P(P), maybe not >>>>>>>>>>>>> the copy that it is simulating, since it aborts that >>>>>>>>>>>>> before it get to it,

    Finally you are not stupid or deceptive.

    If H never returns a value to P then H is not a halting
    decider; if H returns a value of 0 to main() when P halts >>>>>>>>>>> then H is not a halting decider.

    H is not a halting decider; H is a simulation detector, S. >>>>>>>>>>>
    /Flibble


    In other words you are saying the infintely nested emulation >>>>>>>>>> only excutes for a few steps and then it stops on its own.

    I am saying that your H is not a halting decider; I am saying >>>>>>>>> that your H is just a simulation detector, S.

    /Flibble


    You are saying that you simply "don't believe in" simulating
    halt deciders.

    You haven't got a simulating halt decider, what you have got is
    a simulation detector.

    /Flibble


    It is an easily verified fact that H does correctly decide the
    halt status of its input.

    void Infinite_Loop()
    {
    HERE: goto HERE;
    }

    int main()
    {
    Output("Input_Halts = ", H0(Infinite_Loop));
    }

    _Infinite_Loop()
    [00001342](01) 55 push ebp
    [00001343](02) 8bec mov ebp,esp
    [00001345](02) ebfe jmp 00001345
    [00001347](01) 5d pop ebp
    [00001348](01) c3 ret
    Size in bytes:(0007) [00001348]

    _main()
    [00001372](01) 55 push ebp
    [00001373](02) 8bec mov ebp,esp
    [00001375](05) 6842130000 push 00001342
    [0000137a](05) e833fdffff call 000010b2
    [0000137f](03) 83c404 add esp,+04
    [00001382](01) 50 push eax
    [00001383](05) 6823040000 push 00000423
    [00001388](05) e8e5f0ffff call 00000472
    [0000138d](03) 83c408 add esp,+08
    [00001390](02) 33c0 xor eax,eax
    [00001392](01) 5d pop ebp
    [00001393](01) c3 ret
    Size in bytes:(0034) [00001393]

    machine stack stack machine assembly
    address address data code language
    ======== ======== ======== ========= =============
    [00001372][0010228f][00000000] 55 push ebp
    [00001373][0010228f][00000000] 8bec mov ebp,esp
    [00001375][0010228b][00001342] 6842130000 push 00001342 // push
    _Infinite_Loop
    [0000137a][00102287][0000137f] e833fdffff call 000010b2 // call
    H0

    Begin Local Halt Decider Simulation Execution Trace Stored
    at:212343 [00001342][00212333][00212337] 55 push ebp
    [00001343][00212333][00212337] 8bec mov ebp,esp
    [00001345][00212333][00212337] ebfe jmp 00001345
    [00001345][00212333][00212337] ebfe jmp 00001345
    Local Halt Decider: Infinite Loop Detected Simulation Stopped

    [0000137f][0010228f][00000000] 83c404 add esp,+04
    [00001382][0010228b][00000000] 50 push eax
    [00001383][00102287][00000423] 6823040000 push 00000423
    [00001388][00102287][00000423] e8e5f0ffff call 00000472
    Input_Halts = 0
    [0000138d][0010228f][00000000] 83c408 add esp,+08
    [00001390][0010228f][00000000] 33c0 xor eax,eax
    [00001392][00102293][00100000] 5d pop ebp
    [00001393][00102297][00000004] c3 ret
    Number of Instructions Executed(680)

    int Sum(int X, int Y)
    {
    return X + Y;
    }

    int main()
    {
    Output("Input_Halts = ", H2(Sum, 3, 4));
    }

    _Sum()
    [000012b6](01) 55 push ebp
    [000012b7](02) 8bec mov ebp,esp
    [000012b9](03) 8b4508 mov eax,[ebp+08]
    [000012bc](03) 03450c add eax,[ebp+0c]
    [000012bf](01) 5d pop ebp
    [000012c0](01) c3 ret
    Size in bytes:(0011) [000012c0]

    _main()
    [00001316](01) 55 push ebp
    [00001317](02) 8bec mov ebp,esp
    [00001319](02) 6a04 push +04
    [0000131b](02) 6a03 push +03
    [0000131d](05) 68b6120000 push 000012b6
    [00001322](05) e85ffaffff call 00000d86
    [00001327](03) 83c40c add esp,+0c
    [0000132a](01) 50 push eax
    [0000132b](05) 6807040000 push 00000407
    [00001330](05) e821f1ffff call 00000456
    [00001335](03) 83c408 add esp,+08
    [00001338](02) 33c0 xor eax,eax
    [0000133a](01) 5d pop ebp
    [0000133b](01) c3 ret
    Size in bytes:(0038) [0000133b]

    machine stack stack machine assembly
    address address data code language
    ======== ======== ======== ========= =============
    ...[00001316][001021d7][00000000] 55 push ebp
    ...[00001317][001021d7][00000000] 8bec mov ebp,esp
    ...[00001319][001021d3][00000004] 6a04 push +04
    ...[0000131b][001021cf][00000003] 6a03 push +03
    ...[0000131d][001021cb][000012b6] 68b6120000 push 000012b6
    ...[00001322][001021c7][00001327] e85ffaffff call 00000d86

    Begin Local Halt Decider Simulation Execution Trace Stored
    at:21228b ...[000012b6][00212273][00212277] 55 push
    ebp ...[000012b7][00212273][00212277] 8bec mov ebp,esp
    ...[000012b9][00212273][00212277] 8b4508 mov
    eax,[ebp+08] ...[000012bc][00212273][00212277] 03450c
    add eax,[ebp+0c] ...[000012bf][00212277][00000e54] 5d
    pop ebp ...[000012c0][0021227b][00000003] c3 ret
    ...[00001327][001021d7][00000000] 83c40c add esp,+0c
    ...[0000132a][001021d3][00000001] 50 push eax
    ...[0000132b][001021cf][00000407] 6807040000 push 00000407
    ---[00001330][001021cf][00000407] e821f1ffff call 00000456
    Input_Halts = 1
    ...[00001335][001021d7][00000000] 83c408 add esp,+08
    ...[00001338][001021d7][00000000] 33c0 xor eax,eax
    ...[0000133a][001021db][00100000] 5d pop ebp
    ...[0000133b][001021df][00000004] c3 ret
    Number of Instructions Executed(660)

    All you are showing here is that your H can decide the halt status
    of two trivial cases however you have not shown that H can decide
    the halt status of non-trivial cases.


    You said:
    "You haven't got a simulating halt decider"
    Apologize and we can move on.

    I posted four paragraphs but you ignored three of them. Lets try
    again.

    IF YOU DON'T APOLOGIZE THEN WE CANNOT MOVE ON !!!

    It seems I need to try again. Perhaps it will help if I combine the
    four paragraphs into a single paragraph:

    All you are showing here is that your H can decide the halt status of
    two trivial cases however you have not shown that H can decide the halt status of non-trivial cases.

    H is a halt decider for a subset of its inputs.
    H is a halt decider for P.
    When H is a halt decider for P all of the conventional halting problem
    proofs have been refuted.

    Publish the source code of your halt
    decider so we can see what classes of programs your H can decide. I am interested in deciding the halt status of programs containing
    non-trivial branching logic predicated on arbitrary program input.

    These are out-of-scope.

    Crucially if your H cannot return an answer for an arbitrary
    non-halting program in finite time then it isn't a halt decider.

    One can either say that H is a halt decider for a subset of its inputs
    or that H is a halt determiner. As long as H(P,P) correctly decides its
    input all of the conventional HP proofs have been refuted.


    /Flibble



    --
    Copyright 2022 Pete Olcott

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

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mr Flibble@21:1/5 to olcott on Fri Jun 10 14:35:49 2022
    XPost: comp.theory, sci.logic, sci.math

    On Fri, 10 Jun 2022 08:33:27 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/10/2022 8:29 AM, Mr Flibble wrote:
    On Fri, 10 Jun 2022 08:27:28 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/10/2022 8:23 AM, Mr Flibble wrote:
    On Fri, 10 Jun 2022 08:05:57 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/10/2022 6:11 AM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:35:05 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 5:27 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:18:38 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 5:15 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:09:08 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 4:54 PM, Richard Damon wrote:
    On 6/9/22 5:29 PM, olcott wrote:
    On 6/9/2022 4:13 PM, Richard Damon wrote:

    On 6/9/22 5:00 PM, olcott wrote:
    On 6/9/2022 3:25 PM, Richard Damon wrote:
    On 6/9/22 4:13 PM, olcott wrote:
    On 6/9/2022 2:57 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>> On 6/9/22 3:52 PM, olcott wrote:
    On 6/9/2022 2:38 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>
    On 6/9/22 3:26 PM, olcott wrote:
    On 6/9/2022 1:12 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 6/9/22 1:55 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 12:46 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 12:39:32 -0500 >>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>
    On 6/9/2022 12:28 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 12:15:24 -0500 >>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 12:06 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>
    On 6/9/22 12:54 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 11:34 AM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
    On 6/9/22 11:47 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void P(u32 x)
    {
         if (H(x, x)) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>        HERE: goto HERE; >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>      return; >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }

    int main()
    {
         P(P); >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }

    _P()
    [000012e7](01)  55              push
    ebp [000012e8](02)  8bec            mov
    ebp,esp [000012ea](03)  8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08] [000012ed](01)  50 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push eax [000012ee](03)  8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08] [000012f1](01)  51 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ecx [000012f2](05)  e880feffff >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> call 00001177 // call H [000012f7](03) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 83c408 add esp,+08 [000012fa](02)  85c0 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> test eax,eax [000012fc](02)  7402 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> jz 00001300 [000012fe](02)  ebfe >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> jmp 000012fe [00001300](01)  5d >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pop ebp [00001301](01)  c3 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ret Size in bytes:(0027) [00001301] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    _main()
    [00001307](01)  55              push
    ebp [00001308](02)  8bec            mov
    ebp,esp [0000130a](05)  68e7120000 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push 000012e7 // push P [0000130f](05) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e8d3ffffff call 000012e7 // call P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001314](03) 83c404 add esp,+04 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001317](02)  33c0 xor eax,eax >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001319](01)  5d pop ebp >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000131a](01) c3              ret
    Size in bytes:(0020) [0000131a] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
        machine   stack     stack >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine assembly address   address >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> data code language ========  ======== >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ======== ========= ============= >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001307][00102190][00000000] 55 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp [00001308][00102190][00000000] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8bec mov ebp,esp >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000130a][0010218c][000012e7] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 68e7120000 push 000012e7 // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000130f][00102188][00001314] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e8d3ffffff call 000012e7 // call P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e7][00102184][00102190] 55 push >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebp // enter executed P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e8][00102184][00102190] 8bec >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp
    [000012ea][00102184][00102190] 8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ed][00102180][000012e7] 50 push >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> eax // push P
    [000012ee][00102180][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f1][0010217c][000012e7] 51 push >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ecx // push P
    [000012f2][00102178][000012f7] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    Begin Local Halt Decider Simulation >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Execution Trace Stored >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> at:212244
    [000012e7][00212230][00212234] 55 push >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebp // enter emulated P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e8][00212230][00212234] 8bec >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp
    [000012ea][00212230][00212234] 8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ed][0021222c][000012e7] 50 push >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> eax      // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ee][0021222c][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f1][00212228][000012e7] 51 push >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ecx // push P
    [000012f2][00212224][000012f7] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    So, by what instruction reference manual >>>>>>>>>>>>>>>>>>>>>>>>>>>>> is a call 00001177 >>>>>>>>>>>>>>>>>>>>>>>>>>>>> followedby the execution of the >>>>>>>>>>>>>>>>>>>>>>>>>>>>> instruction at 000012e7. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    Your "CPU" is broken, or emulation >>>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect.

    FAIL.
    [000012e7][0025cc58][0025cc5c] 55 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp      // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> enter emulated P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e8][0025cc58][0025cc5c] 8bec >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp
    [000012ea][0025cc58][0025cc5c] 8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ed][0025cc54][000012e7] 50 push >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> eax      // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ee][0025cc54][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f1][0025cc50][000012e7] 51 push >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ecx // push P
    [000012f2][0025cc4c][000012f7] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Local Halt Decider: Infinite Recursion >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Detected Simulation Stopped >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    It is completely obvious that when >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) correctly emulates >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input that it must emulate the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> first seven instructions of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P. Because the seventh instruction of P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeats this process we >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> know with complete certainty that the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulation of P by H would never reach >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its final “ret” instruction, thus never >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts.

    Problem, the 7th intruction DOESN't >>>>>>>>>>>>>>>>>>>>>>>>>>>>> "Just repeat the procedure", >>>>>>>>>>>>>>>>>>>>>>>>>>>>> because that H always has the option to >>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort its simulation, >>>>>>>>>>>>>>>>>>>>>>>>>>>>> just like this onne did, and return to >>>>>>>>>>>>>>>>>>>>>>>>>>>>> its P and see it halt. >>>>>>>>>>>>>>>>>>>>>>>>>>>> THAT YOU ARE SIMPLY TOO STUPID TO >>>>>>>>>>>>>>>>>>>>>>>>>>>> UNDERSTAND THIS IS NO ACTUAL >>>>>>>>>>>>>>>>>>>>>>>>>>>> REBUTTAL AT ALL:

    The partial correct x86 emulation of the >>>>>>>>>>>>>>>>>>>>>>>>>>>> input to H(P,P) conclusively proves that >>>>>>>>>>>>>>>>>>>>>>>>>>>> the complete and correct x86 emulation >>>>>>>>>>>>>>>>>>>>>>>>>>>> would never stop running. >>>>>>>>>>>>>>>>>>>>>>>>>>>>

    You SAY that, but you don't answer the >>>>>>>>>>>>>>>>>>>>>>>>>>> actual questions about HOW. >>>>>>>>>>>>>>>>>>>>>>>>>>
    THAT YOU ARE SIMPLY TOO STUPID TO >>>>>>>>>>>>>>>>>>>>>>>>>> UNDERSTAND THIS IS NO EVIDENCE >>>>>>>>>>>>>>>>>>>>>>>>>> WHAT-SO-EVER THAT I DID NOT COMPLETELY >>>>>>>>>>>>>>>>>>>>>>>>>> PROVE THAT THE CORRECT
    PARTIAL EMULATION OF THE INPUT TO H(P,P) >>>>>>>>>>>>>>>>>>>>>>>>>> CONCLUSIVELY PROVES THAT >>>>>>>>>>>>>>>>>>>>>>>>>> THE CORRECT AND COMPLETE X86 EMULATION OF >>>>>>>>>>>>>>>>>>>>>>>>>> THE INPUT TO H(P,P)
    WOULD NEVER STOP RUNNING. >>>>>>>>>>>>>>>>>>>>>>>>>>
    It is completely obvious that when H(P,P) >>>>>>>>>>>>>>>>>>>>>>>>>> correctly emulates its
    input that it must emulate the first seven >>>>>>>>>>>>>>>>>>>>>>>>>> instructions of P.
    Because the seventh instruction of P >>>>>>>>>>>>>>>>>>>>>>>>>> repeats this process we know >>>>>>>>>>>>>>>>>>>>>>>>>> with complete certainty that the correct >>>>>>>>>>>>>>>>>>>>>>>>>> and complete emulation of >>>>>>>>>>>>>>>>>>>>>>>>>> P by H would never reach its final “ret” >>>>>>>>>>>>>>>>>>>>>>>>>> instruction, thus never
    halts.

    If P should have halted (i.e. no infinite >>>>>>>>>>>>>>>>>>>>>>>>> loop) then your simulation >>>>>>>>>>>>>>>>>>>>>>>>> detector, S (not H), gets the answer wrong. >>>>>>>>>>>>>>>>>>>>>>>>> You S is NOT a halting
    decider.

    /Flibble

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND >>>>>>>>>>>>>>>>>>>>>>>> THIS IS NO ACTUAL
    REBUTTAL AT ALL.

    _P()
    [00001352](01)  55              push ebp
    [00001353](02)  8bec            mov ebp,esp
    [00001355](03)  8b4508          mov >>>>>>>>>>>>>>>>>>>>>>>> eax,[ebp+08] [00001358](01)  50 >>>>>>>>>>>>>>>>>>>>>>>> push eax      // push P [00001359](03) >>>>>>>>>>>>>>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08] [0000135c](01)  51 >>>>>>>>>>>>>>>>>>>>>>>>            push ecx      // push P >>>>>>>>>>>>>>>>>>>>>>>> [0000135d](05)  e840feffff call 000011a2 // >>>>>>>>>>>>>>>>>>>>>>>> call H [00001362](03)  83c408 add esp,+08 >>>>>>>>>>>>>>>>>>>>>>>> [00001365](02)  85c0 test eax,eax >>>>>>>>>>>>>>>>>>>>>>>> [00001367](02)  7402            jz 0000136b
    [00001369](02)  ebfe            jmp 00001369
    [0000136b](01)  5d              pop ebp
    [0000136c](01)  c3              ret Size in
    bytes:(0027) [0000136c]

    It is completely obvious that when H(P,P) >>>>>>>>>>>>>>>>>>>>>>>> correctly emulates its
    input that it must emulate the first seven >>>>>>>>>>>>>>>>>>>>>>>> instructions of P. Because
    the seventh instruction of P repeats this >>>>>>>>>>>>>>>>>>>>>>>> process we know with
    complete certainty that the correct and >>>>>>>>>>>>>>>>>>>>>>>> complete emulation of P by H >>>>>>>>>>>>>>>>>>>>>>>> would never reach its final “ret” >>>>>>>>>>>>>>>>>>>>>>>> instruction, thus never halts. >>>>>>>>>>>>>>>>>>>>>>>
    We are going around and around and around in >>>>>>>>>>>>>>>>>>>>>>> circles. I will try again:

    If you replace the opcodes "EB FE" at 00001369 >>>>>>>>>>>>>>>>>>>>>>> with the opcodes "90 90"
    then your H gets the answer wrong: P should >>>>>>>>>>>>>>>>>>>>>>> have halted.

    /Flibble


    As I already said before this is merely your >>>>>>>>>>>>>>>>>>>>>> cluelessness that when H(P,P) is invoked the >>>>>>>>>>>>>>>>>>>>>> correct x86 emulation of the input to H(P,P) >>>>>>>>>>>>>>>>>>>>>> makes and code after [0000135d] unreachable. >>>>>>>>>>>>>>>>>>>>>
    Wrong, because when that H return the value 0, >>>>>>>>>>>>>>>>>>>>> it will get there.
    Like I said people that are dumber than a box of >>>>>>>>>>>>>>>>>>>> rocks won't be able to correctly understand this. >>>>>>>>>>>>>>>>>>>>
    When H(P,P) is invoked the correctly emulated >>>>>>>>>>>>>>>>>>>> input to H(P,P) cannot possibly reach any >>>>>>>>>>>>>>>>>>>> instruction beyond [0000135d].

    So, you are defining that you H(P,P) never returns >>>>>>>>>>>>>>>>>>> because it is caught in the infinite rcursion. >>>>>>>>>>>>>>>>>>>
    Thats fine, just says it can't be the correctly >>>>>>>>>>>>>>>>>>> answering decider you claim it to be. >>>>>>>>>>>>>>>>>>
    I have corrected you on this too many times. >>>>>>>>>>>>>>>>>>

    How. You need to define what H(P,P) actually does. >>>>>>>>>>>>>>>>
    I have explained that too many times.

    To understand that H(P,P)==0 is correct we only need >>>>>>>>>>>>>>>> to know that H performs a correct x86 emulation of >>>>>>>>>>>>>>>> its input and then examine the execution trace. >>>>>>>>>>>>>>>
    And a CORRECT emulation of the code will Halt if >>>>>>>>>>>>>>> H(P,P) returns 0, which it can only do if it does not >>>>>>>>>>>>>>> actually do a correct emulation

    The correctly emulated input to H(P,P) never gets past >>>>>>>>>>>>>> its machine address [0000135d].



    Only if H actually doesn't return 0. Yes, H can't
    correctly return 0 if it correctly emulates its input, >>>>>>>>>>>>> but you can't drop that requirement.

    void P(u32 x)
    {
       if (H(x, x))
         HERE: goto HERE;
       return;
    }

    int main()
    {
       Output("Input_Halts = ", H((u32)P, (u32)P)); >>>>>>>>>>>> }

    When H returns 0 it does not returns 0 to P it returns 0 >>>>>>>>>>>> to main().

    But it also return 0 to the computation P(P), maybe not >>>>>>>>>>> the copy that it is simulating, since it aborts that
    before it get to it,

    Finally you are not stupid or deceptive.

    If H never returns a value to P then H is not a halting
    decider; if H returns a value of 0 to main() when P halts
    then H is not a halting decider.

    H is not a halting decider; H is a simulation detector, S. >>>>>>>>>
    /Flibble


    In other words you are saying the infintely nested emulation >>>>>>>> only excutes for a few steps and then it stops on its own.

    I am saying that your H is not a halting decider; I am saying
    that your H is just a simulation detector, S.

    /Flibble


    You are saying that you simply "don't believe in" simulating
    halt deciders.

    You haven't got a simulating halt decider, what you have got is
    a simulation detector.

    /Flibble


    It is an easily verified fact that H does correctly decide the
    halt status of its input.

    void Infinite_Loop()
    {
    HERE: goto HERE;
    }

    int main()
    {
    Output("Input_Halts = ", H0(Infinite_Loop));
    }

    _Infinite_Loop()
    [00001342](01) 55 push ebp
    [00001343](02) 8bec mov ebp,esp
    [00001345](02) ebfe jmp 00001345
    [00001347](01) 5d pop ebp
    [00001348](01) c3 ret
    Size in bytes:(0007) [00001348]

    _main()
    [00001372](01) 55 push ebp
    [00001373](02) 8bec mov ebp,esp
    [00001375](05) 6842130000 push 00001342
    [0000137a](05) e833fdffff call 000010b2
    [0000137f](03) 83c404 add esp,+04
    [00001382](01) 50 push eax
    [00001383](05) 6823040000 push 00000423
    [00001388](05) e8e5f0ffff call 00000472
    [0000138d](03) 83c408 add esp,+08
    [00001390](02) 33c0 xor eax,eax
    [00001392](01) 5d pop ebp
    [00001393](01) c3 ret
    Size in bytes:(0034) [00001393]

    machine stack stack machine assembly
    address address data code language
    ======== ======== ======== ========= =============
    [00001372][0010228f][00000000] 55 push ebp
    [00001373][0010228f][00000000] 8bec mov ebp,esp
    [00001375][0010228b][00001342] 6842130000 push 00001342 // push
    _Infinite_Loop
    [0000137a][00102287][0000137f] e833fdffff call 000010b2 // call
    H0

    Begin Local Halt Decider Simulation Execution Trace Stored
    at:212343 [00001342][00212333][00212337] 55 push ebp
    [00001343][00212333][00212337] 8bec mov ebp,esp
    [00001345][00212333][00212337] ebfe jmp 00001345
    [00001345][00212333][00212337] ebfe jmp 00001345
    Local Halt Decider: Infinite Loop Detected Simulation Stopped

    [0000137f][0010228f][00000000] 83c404 add esp,+04
    [00001382][0010228b][00000000] 50 push eax
    [00001383][00102287][00000423] 6823040000 push 00000423
    [00001388][00102287][00000423] e8e5f0ffff call 00000472
    Input_Halts = 0
    [0000138d][0010228f][00000000] 83c408 add esp,+08
    [00001390][0010228f][00000000] 33c0 xor eax,eax
    [00001392][00102293][00100000] 5d pop ebp
    [00001393][00102297][00000004] c3 ret
    Number of Instructions Executed(680)

    int Sum(int X, int Y)
    {
    return X + Y;
    }

    int main()
    {
    Output("Input_Halts = ", H2(Sum, 3, 4));
    }

    _Sum()
    [000012b6](01) 55 push ebp
    [000012b7](02) 8bec mov ebp,esp
    [000012b9](03) 8b4508 mov eax,[ebp+08]
    [000012bc](03) 03450c add eax,[ebp+0c]
    [000012bf](01) 5d pop ebp
    [000012c0](01) c3 ret
    Size in bytes:(0011) [000012c0]

    _main()
    [00001316](01) 55 push ebp
    [00001317](02) 8bec mov ebp,esp
    [00001319](02) 6a04 push +04
    [0000131b](02) 6a03 push +03
    [0000131d](05) 68b6120000 push 000012b6
    [00001322](05) e85ffaffff call 00000d86
    [00001327](03) 83c40c add esp,+0c
    [0000132a](01) 50 push eax
    [0000132b](05) 6807040000 push 00000407
    [00001330](05) e821f1ffff call 00000456
    [00001335](03) 83c408 add esp,+08
    [00001338](02) 33c0 xor eax,eax
    [0000133a](01) 5d pop ebp
    [0000133b](01) c3 ret
    Size in bytes:(0038) [0000133b]

    machine stack stack machine assembly
    address address data code language
    ======== ======== ======== ========= =============
    ...[00001316][001021d7][00000000] 55 push ebp
    ...[00001317][001021d7][00000000] 8bec mov ebp,esp
    ...[00001319][001021d3][00000004] 6a04 push +04
    ...[0000131b][001021cf][00000003] 6a03 push +03
    ...[0000131d][001021cb][000012b6] 68b6120000 push 000012b6
    ...[00001322][001021c7][00001327] e85ffaffff call 00000d86

    Begin Local Halt Decider Simulation Execution Trace Stored
    at:21228b ...[000012b6][00212273][00212277] 55 push
    ebp ...[000012b7][00212273][00212277] 8bec mov ebp,esp
    ...[000012b9][00212273][00212277] 8b4508 mov
    eax,[ebp+08] ...[000012bc][00212273][00212277] 03450c
    add eax,[ebp+0c] ...[000012bf][00212277][00000e54] 5d
    pop ebp ...[000012c0][0021227b][00000003] c3 ret
    ...[00001327][001021d7][00000000] 83c40c add esp,+0c
    ...[0000132a][001021d3][00000001] 50 push eax
    ...[0000132b][001021cf][00000407] 6807040000 push 00000407
    ---[00001330][001021cf][00000407] e821f1ffff call 00000456
    Input_Halts = 1
    ...[00001335][001021d7][00000000] 83c408 add esp,+08
    ...[00001338][001021d7][00000000] 33c0 xor eax,eax
    ...[0000133a][001021db][00100000] 5d pop ebp
    ...[0000133b][001021df][00000004] c3 ret
    Number of Instructions Executed(660)

    All you are showing here is that your H can decide the halt status
    of two trivial cases however you have not shown that H can decide
    the halt status of non-trivial cases.


    You said:
    "You haven't got a simulating halt decider"
    Apologize and we can move on.

    I posted four paragraphs but you ignored three of them. Lets try
    again.

    IF YOU DON'T APOLOGIZE THEN WE CANNOT MOVE ON !!!

    It seems I need to try again. Perhaps it will help if I combine the
    four paragraphs into a single paragraph:

    All you are showing here is that your H can decide the halt status of
    two trivial cases however you have not shown that H can decide the halt
    status of non-trivial cases. Publish the source code of your halt
    decider so we can see what classes of programs your H can decide. I am interested in deciding the halt status of programs containing
    non-trivial branching logic predicated on arbitrary program input.
    Crucially if your H cannot return an answer for an arbitrary
    non-halting program in finite time then it isn't a halt decider.

    /Flibble

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Fri Jun 10 09:50:38 2022
    XPost: comp.theory, sci.logic, sci.math

    On 6/10/22 9:33 AM, olcott wrote:
    On 6/10/2022 8:29 AM, Mr Flibble wrote:
    On Fri, 10 Jun 2022 08:27:28 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/10/2022 8:23 AM, Mr Flibble wrote:
    On Fri, 10 Jun 2022 08:05:57 -0500
    olcott <NoOne@NoWhere.com> wrote:
    On 6/10/2022 6:11 AM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:35:05 -0500
    olcott <NoOne@NoWhere.com> wrote:
    On 6/9/2022 5:27 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:18:38 -0500
    olcott <NoOne@NoWhere.com> wrote:
    On 6/9/2022 5:15 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:09:08 -0500
    olcott <NoOne@NoWhere.com> wrote:
    On 6/9/2022 4:54 PM, Richard Damon wrote:
    On 6/9/22 5:29 PM, olcott wrote:
    On 6/9/2022 4:13 PM, Richard Damon wrote:

    On 6/9/22 5:00 PM, olcott wrote:
    On 6/9/2022 3:25 PM, Richard Damon wrote:
    On 6/9/22 4:13 PM, olcott wrote:
    On 6/9/2022 2:57 PM, Richard Damon wrote:
    On 6/9/22 3:52 PM, olcott wrote:
    On 6/9/2022 2:38 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>
    On 6/9/22 3:26 PM, olcott wrote:
    On 6/9/2022 1:12 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 6/9/22 1:55 PM, olcott wrote:
    On 6/9/2022 12:46 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 12:39:32 -0500 >>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 12:28 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 12:15:24 -0500 >>>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 12:06 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 12:54 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 11:34 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 11:47 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void P(u32 x)
    {
              if (H(x, x)) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>             HERE: goto HERE; >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>           return; >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }

    int main()
    {
              P(P); >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }

    _P()
    [000012e7](01)  55              push ebp
    [000012e8](02)  8bec            mov >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp [000012ea](03)  8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08] [000012ed](01)  50 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push eax [000012ee](03)  8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08] [000012f1](01)  51 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ecx [000012f2](05)  e880feffff >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> call 00001177 // call H [000012f7](03) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 83c408 add esp,+08 [000012fa](02)  85c0 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>      test eax,eax [000012fc](02)  7402 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> jz 00001300 [000012fe](02)  ebfe >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> jmp 000012fe [00001300](01)  5d >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pop ebp [00001301](01)  c3 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ret Size in bytes:(0027) [00001301] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    _main()
    [00001307](01)  55              push ebp
    [00001308](02)  8bec            mov >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp [0000130a](05)  68e7120000 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push 000012e7 // push P [0000130f](05) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e8d3ffffff call 000012e7 // call P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001314](03) 83c404 add esp,+04 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001317](02)  33c0 xor eax,eax >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001319](01)  5d pop ebp [0000131a](01) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> c3              ret Size in bytes:(0020)
    [0000131a]

             machine   stack     stack >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine assembly address   address   data >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>       code language ========  ======== >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ======== ========= ============= >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001307][00102190][00000000] 55 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp [00001308][00102190][00000000] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8bec mov ebp,esp >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000130a][0010218c][000012e7] 68e7120000 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push 000012e7 // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000130f][00102188][00001314] e8d3ffffff >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> call 000012e7 // call P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e7][00102184][00102190] 55 push >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebp // enter executed P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e8][00102184][00102190] 8bec >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp
    [000012ea][00102184][00102190] 8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ed][00102180][000012e7] 50 push >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> eax // push P
    [000012ee][00102180][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f1][0010217c][000012e7] 51 push >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ecx // push P
    [000012f2][00102178][000012f7] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    Begin Local Halt Decider Simulation >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Execution Trace Stored >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> at:212244 [000012e7][00212230][00212234] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 55 push ebp // enter emulated P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e8][00212230][00212234] 8bec >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp
    [000012ea][00212230][00212234] 8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ed][0021222c][000012e7] 50 push >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> eax      // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ee][0021222c][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f1][00212228][000012e7] 51 push >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ecx // push P
    [000012f2][00212224][000012f7] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    So, by what instruction reference manual >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is a call 00001177 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> followedby the execution of the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instruction at 000012e7. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    Your "CPU" is broken, or emulation >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect.

    FAIL.
    [000012e7][0025cc58][0025cc5c] 55 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp      // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> enter emulated P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e8][0025cc58][0025cc5c] 8bec >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp
    [000012ea][0025cc58][0025cc5c] 8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ed][0025cc54][000012e7] 50 push >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> eax      // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ee][0025cc54][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f1][0025cc50][000012e7] 51 push >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ecx // push P
    [000012f2][0025cc4c][000012f7] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H Local >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halt Decider: Infinite Recursion >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Detected Simulation Stopped >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    It is completely obvious that when H(P,P) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly emulates >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input that it must emulate the first >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> seven instructions of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P. Because the seventh instruction of P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeats this process we >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> know with complete certainty that the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulation of P by H would never reach its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final “ret” instruction, thus never >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts.

    Problem, the 7th intruction DOESN't "Just >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeat the procedure", >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because that H always has the option to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort its simulation, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just like this onne did, and return to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its P and see it halt. >>>>>>>>>>>>>>>>>>>>>>>>>>>>> THAT YOU ARE SIMPLY TOO STUPID TO >>>>>>>>>>>>>>>>>>>>>>>>>>>>> UNDERSTAND THIS IS NO ACTUAL >>>>>>>>>>>>>>>>>>>>>>>>>>>>> REBUTTAL AT ALL:

    The partial correct x86 emulation of the >>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to H(P,P) conclusively proves that >>>>>>>>>>>>>>>>>>>>>>>>>>>>> the complete and correct x86 emulation >>>>>>>>>>>>>>>>>>>>>>>>>>>>> would never stop running. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
    You SAY that, but you don't answer the >>>>>>>>>>>>>>>>>>>>>>>>>>>> actual questions about HOW. >>>>>>>>>>>>>>>>>>>>>>>>>>>
    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND >>>>>>>>>>>>>>>>>>>>>>>>>>> THIS IS NO EVIDENCE
    WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE >>>>>>>>>>>>>>>>>>>>>>>>>>> THAT THE CORRECT
    PARTIAL EMULATION OF THE INPUT TO H(P,P) >>>>>>>>>>>>>>>>>>>>>>>>>>> CONCLUSIVELY PROVES THAT >>>>>>>>>>>>>>>>>>>>>>>>>>> THE CORRECT AND COMPLETE X86 EMULATION OF THE >>>>>>>>>>>>>>>>>>>>>>>>>>> INPUT TO H(P,P)
    WOULD NEVER STOP RUNNING. >>>>>>>>>>>>>>>>>>>>>>>>>>>
    It is completely obvious that when H(P,P) >>>>>>>>>>>>>>>>>>>>>>>>>>> correctly emulates its
    input that it must emulate the first seven >>>>>>>>>>>>>>>>>>>>>>>>>>> instructions of P.
    Because the seventh instruction of P repeats >>>>>>>>>>>>>>>>>>>>>>>>>>> this process we know
    with complete certainty that the correct and >>>>>>>>>>>>>>>>>>>>>>>>>>> complete emulation of
    P by H would never reach its final “ret” >>>>>>>>>>>>>>>>>>>>>>>>>>> instruction, thus never
    halts.

    If P should have halted (i.e. no infinite >>>>>>>>>>>>>>>>>>>>>>>>>> loop) then your simulation >>>>>>>>>>>>>>>>>>>>>>>>>> detector, S (not H), gets the answer wrong. >>>>>>>>>>>>>>>>>>>>>>>>>> You S is NOT a halting
    decider.

    /Flibble

    THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND >>>>>>>>>>>>>>>>>>>>>>>>> THIS IS NO ACTUAL
    REBUTTAL AT ALL.

    _P()
    [00001352](01)  55              push ebp
    [00001353](02)  8bec            mov ebp,esp
    [00001355](03)  8b4508          mov >>>>>>>>>>>>>>>>>>>>>>>>> eax,[ebp+08] [00001358](01)  50 >>>>>>>>>>>>>>>>>>>>>>>>> push eax      // push P [00001359](03)  8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>           mov ecx,[ebp+08] [0000135c](01)  51
                push ecx      // push P >>>>>>>>>>>>>>>>>>>>>>>>> [0000135d](05)  e840feffff call 000011a2 // >>>>>>>>>>>>>>>>>>>>>>>>> call H [00001362](03)  83c408 add esp,+08 >>>>>>>>>>>>>>>>>>>>>>>>> [00001365](02)  85c0 test eax,eax >>>>>>>>>>>>>>>>>>>>>>>>> [00001367](02)  7402            jz 0000136b
    [00001369](02)  ebfe            jmp 00001369
    [0000136b](01)  5d              pop ebp >>>>>>>>>>>>>>>>>>>>>>>>> [0000136c](01)  c3              ret Size in
    bytes:(0027) [0000136c]

    It is completely obvious that when H(P,P) >>>>>>>>>>>>>>>>>>>>>>>>> correctly emulates its
    input that it must emulate the first seven >>>>>>>>>>>>>>>>>>>>>>>>> instructions of P. Because
    the seventh instruction of P repeats this >>>>>>>>>>>>>>>>>>>>>>>>> process we know with
    complete certainty that the correct and >>>>>>>>>>>>>>>>>>>>>>>>> complete emulation of P by H >>>>>>>>>>>>>>>>>>>>>>>>> would never reach its final “ret” instruction, >>>>>>>>>>>>>>>>>>>>>>>>> thus never halts.

    We are going around and around and around in >>>>>>>>>>>>>>>>>>>>>>>> circles. I will try again:

    If you replace the opcodes "EB FE" at 00001369 >>>>>>>>>>>>>>>>>>>>>>>> with the opcodes "90 90"
    then your H gets the answer wrong: P should have >>>>>>>>>>>>>>>>>>>>>>>> halted.

    /Flibble

    As I already said before this is merely your >>>>>>>>>>>>>>>>>>>>>>> cluelessness that when H(P,P) is invoked the >>>>>>>>>>>>>>>>>>>>>>> correct x86 emulation of the input to H(P,P) >>>>>>>>>>>>>>>>>>>>>>> makes and code after [0000135d] unreachable. >>>>>>>>>>>>>>>>>>>>>>
    Wrong, because when that H return the value 0, it >>>>>>>>>>>>>>>>>>>>>> will get there.
    Like I said people that are dumber than a box of >>>>>>>>>>>>>>>>>>>>> rocks won't be able to correctly understand this. >>>>>>>>>>>>>>>>>>>>>
    When H(P,P) is invoked the correctly emulated input >>>>>>>>>>>>>>>>>>>>> to H(P,P) cannot possibly reach any instruction >>>>>>>>>>>>>>>>>>>>> beyond [0000135d].

    So, you are defining that you H(P,P) never returns >>>>>>>>>>>>>>>>>>>> because it is caught in the infinite rcursion. >>>>>>>>>>>>>>>>>>>>
    Thats fine, just says it can't be the correctly >>>>>>>>>>>>>>>>>>>> answering decider you claim it to be.

    I have corrected you on this too many times. >>>>>>>>>>>>>>>>>>
    How. You need to define what H(P,P) actually does. >>>>>>>>>>>>>>>>>
    I have explained that too many times.

    To understand that H(P,P)==0 is correct we only need to >>>>>>>>>>>>>>>>> know that H performs a correct x86 emulation of its >>>>>>>>>>>>>>>>> input and then examine the execution trace.

    And a CORRECT emulation of the code will Halt if H(P,P) >>>>>>>>>>>>>>>> returns 0, which it can only do if it does not actually >>>>>>>>>>>>>>>> do a correct emulation

    The correctly emulated input to H(P,P) never gets past >>>>>>>>>>>>>>> its machine address [0000135d].


    Only if H actually doesn't return 0. Yes, H can't
    correctly return 0 if it correctly emulates its input, >>>>>>>>>>>>>> but you can't drop that requirement.

    void P(u32 x)
    {
            if (H(x, x))
              HERE: goto HERE;
            return;
    }

    int main()
    {
            Output("Input_Halts = ", H((u32)P, (u32)P)); >>>>>>>>>>>>> }

    When H returns 0 it does not returns 0 to P it returns 0 to >>>>>>>>>>>>> main().

    But it also return 0 to the computation P(P), maybe not the >>>>>>>>>>>> copy that it is simulating, since it aborts that before it >>>>>>>>>>>> get to it,

    Finally you are not stupid or deceptive.

    If H never returns a value to P then H is not a halting
    decider; if H returns a value of 0 to main() when P halts
    then H is not a halting decider.

    H is not a halting decider; H is a simulation detector, S. >>>>>>>>>>
    /Flibble

    In other words you are saying the infintely nested emulation >>>>>>>>> only excutes for a few steps and then it stops on its own.
    I am saying that your H is not a halting decider; I am saying
    that your H is just a simulation detector, S.

    /Flibble

    You are saying that you simply "don't believe in" simulating halt >>>>>>> deciders.
    You haven't got a simulating halt decider, what you have got is a
    simulation detector.

    /Flibble

    It is an easily verified fact that H does correctly decide the halt
    status of its input.

    void Infinite_Loop()
    {
         HERE: goto HERE;
    }

    int main()
    {
         Output("Input_Halts = ", H0(Infinite_Loop));
    }

    _Infinite_Loop()
    [00001342](01)  55              push ebp
    [00001343](02)  8bec            mov ebp,esp
    [00001345](02)  ebfe            jmp 00001345
    [00001347](01)  5d              pop ebp
    [00001348](01)  c3              ret
    Size in bytes:(0007) [00001348]

    _main()
    [00001372](01)  55              push ebp
    [00001373](02)  8bec            mov ebp,esp
    [00001375](05)  6842130000      push 00001342
    [0000137a](05)  e833fdffff      call 000010b2
    [0000137f](03)  83c404          add esp,+04
    [00001382](01)  50              push eax
    [00001383](05)  6823040000      push 00000423
    [00001388](05)  e8e5f0ffff      call 00000472
    [0000138d](03)  83c408          add esp,+08
    [00001390](02)  33c0            xor eax,eax
    [00001392](01)  5d              pop ebp
    [00001393](01)  c3              ret
    Size in bytes:(0034) [00001393]

        machine   stack     stack     machine    assembly >>>>>     address   address   data      code       language >>>>>     ========  ========  ========  =========  =============
    [00001372][0010228f][00000000] 55         push ebp
    [00001373][0010228f][00000000] 8bec       mov ebp,esp
    [00001375][0010228b][00001342] 6842130000 push 00001342 // push
    _Infinite_Loop
    [0000137a][00102287][0000137f] e833fdffff call 000010b2 // call H0

    Begin Local Halt Decider Simulation   Execution Trace Stored
    at:212343 [00001342][00212333][00212337] 55         push ebp >>>>> [00001343][00212333][00212337] 8bec       mov ebp,esp
    [00001345][00212333][00212337] ebfe       jmp 00001345
    [00001345][00212333][00212337] ebfe       jmp 00001345
    Local Halt Decider: Infinite Loop Detected Simulation Stopped

    [0000137f][0010228f][00000000] 83c404     add esp,+04
    [00001382][0010228b][00000000] 50         push eax
    [00001383][00102287][00000423] 6823040000 push 00000423
    [00001388][00102287][00000423] e8e5f0ffff call 00000472
    Input_Halts = 0
    [0000138d][0010228f][00000000] 83c408     add esp,+08
    [00001390][0010228f][00000000] 33c0       xor eax,eax
    [00001392][00102293][00100000] 5d         pop ebp
    [00001393][00102297][00000004] c3         ret
    Number of Instructions Executed(680)

    int Sum(int X, int Y)
    {
         return X + Y;
    }

    int main()
    {
         Output("Input_Halts = ", H2(Sum, 3, 4));
    }

    _Sum()
    [000012b6](01)  55              push ebp
    [000012b7](02)  8bec            mov ebp,esp
    [000012b9](03)  8b4508          mov eax,[ebp+08]
    [000012bc](03)  03450c          add eax,[ebp+0c]
    [000012bf](01)  5d              pop ebp
    [000012c0](01)  c3              ret
    Size in bytes:(0011) [000012c0]

    _main()
    [00001316](01)  55              push ebp
    [00001317](02)  8bec            mov ebp,esp
    [00001319](02)  6a04            push +04
    [0000131b](02)  6a03            push +03
    [0000131d](05)  68b6120000      push 000012b6
    [00001322](05)  e85ffaffff      call 00000d86
    [00001327](03)  83c40c          add esp,+0c
    [0000132a](01)  50              push eax
    [0000132b](05)  6807040000      push 00000407
    [00001330](05)  e821f1ffff      call 00000456
    [00001335](03)  83c408          add esp,+08
    [00001338](02)  33c0            xor eax,eax
    [0000133a](01)  5d              pop ebp
    [0000133b](01)  c3              ret
    Size in bytes:(0038) [0000133b]

        machine   stack     stack     machine    assembly >>>>>     address   address   data      code       language >>>>>     ========  ========  ========  =========  =============
    ...[00001316][001021d7][00000000] 55              push ebp >>>>> ...[00001317][001021d7][00000000] 8bec            mov ebp,esp >>>>> ...[00001319][001021d3][00000004] 6a04            push +04 >>>>> ...[0000131b][001021cf][00000003] 6a03            push +03 >>>>> ...[0000131d][001021cb][000012b6] 68b6120000      push 000012b6 >>>>> ...[00001322][001021c7][00001327] e85ffaffff      call 00000d86 >>>>>
    Begin Local Halt Decider Simulation   Execution Trace Stored
    at:21228b ...[000012b6][00212273][00212277] 55              push
    ebp ...[000012b7][00212273][00212277] 8bec            mov ebp,esp
    ...[000012b9][00212273][00212277] 8b4508          mov eax,[ebp+08]
    ...[000012bc][00212273][00212277] 03450c          add eax,[ebp+0c]
    ...[000012bf][00212277][00000e54] 5d              pop ebp >>>>> ...[000012c0][0021227b][00000003] c3              ret
    ...[00001327][001021d7][00000000] 83c40c          add esp,+0c >>>>> ...[0000132a][001021d3][00000001] 50              push eax >>>>> ...[0000132b][001021cf][00000407] 6807040000      push 00000407 >>>>> ---[00001330][001021cf][00000407] e821f1ffff      call 00000456 >>>>> Input_Halts = 1
    ...[00001335][001021d7][00000000] 83c408          add esp,+08 >>>>> ...[00001338][001021d7][00000000] 33c0            xor eax,eax >>>>> ...[0000133a][001021db][00100000] 5d              pop ebp >>>>> ...[0000133b][001021df][00000004] c3              ret
    Number of Instructions Executed(660)

    All you are showing here is that your H can decide the halt status
    of two trivial cases however you have not shown that H can decide
    the halt status of non-trivial cases.

    You said:
    "You haven't got a simulating halt decider"
    Apologize and we can move on.

    I posted four paragraphs but you ignored three of them. Lets try again.


    IF YOU DON'T APOLOGIZE THEN WE CANNOT MOVE ON !!!

    Why are you insisting on an apology for them telling the truth.

    You DON'T have "A Simulating Halt Decider" (at least by the standard definitions) because by normal English Grammer and composistion rules, a Simulating Halt Decider needs to meet all the requirements of being a
    Halt Decider, which H doesn't

    Remember, a Halt Decider is DEFINED to answer about the behavior of the
    actual Turing Machine, that has be represented in its input, being
    applied to the input that is also specified in its input.

    You have SPECIFICALLY claimed that the you H only needs to answer about
    the behavior of its actual input, and tha you are defining that, at
    least for the case of H(P,P) that that is NOT P(P).

    Since you are specifically saying what you are calling a "Simulating
    Halt Decider" doesn't need to meet the actual requirements of a Halt
    Decider, what you are wanting to call a "Simulating Halt Decider" isn't actually a Simulating Halt Decider.

    What you are doing is exactly like the crazy person who wants to call
    their dog a cat getting upset about someone saying they don't have a
    cat. They DON'T have a cat, they have a Dog. In the say way, your H is
    NOT actually "Simulating Halt Decider" but something else, because it
    doesn't meet the definition, since you refuse to let it have the right requirements.

    This means in a real sense it isn't even an incorrect halt decider,
    because you have defined that to domain of its inputs aren't the same
    domain as a Halt Decider.


    All you are showing here is that your H can decide the halt status of
    two trivial cases however you have not shown that H can decide the halt
    status of non-trivial cases.

    Publish the source code of your halt decider so we can see what classes
    of programs your H can decide.

    I am interested in deciding the halt status of programs containing
    non-trivial branching logic predicated on arbitrary program input.

    Crucially if your H cannot return an answer for an arbitrary
    non-halting program in finite time then it isn't a halt decider.

    /Flibble




    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mr Flibble@21:1/5 to olcott on Fri Jun 10 14:51:24 2022
    XPost: comp.theory, sci.logic, sci.math

    On Fri, 10 Jun 2022 08:43:48 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/10/2022 8:35 AM, Mr Flibble wrote:
    On Fri, 10 Jun 2022 08:33:27 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/10/2022 8:29 AM, Mr Flibble wrote:
    On Fri, 10 Jun 2022 08:27:28 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/10/2022 8:23 AM, Mr Flibble wrote:
    On Fri, 10 Jun 2022 08:05:57 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/10/2022 6:11 AM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:35:05 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 5:27 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:18:38 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 5:15 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:09:08 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 4:54 PM, Richard Damon wrote:
    On 6/9/22 5:29 PM, olcott wrote:
    On 6/9/2022 4:13 PM, Richard Damon wrote:

    On 6/9/22 5:00 PM, olcott wrote:
    On 6/9/2022 3:25 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>> On 6/9/22 4:13 PM, olcott wrote:
    On 6/9/2022 2:57 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 6/9/22 3:52 PM, olcott wrote:
    On 6/9/2022 2:38 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>
    On 6/9/22 3:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 1:12 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 1:55 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 12:46 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 12:39:32 -0500 >>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>
    On 6/9/2022 12:28 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 12:15:24 -0500 >>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 12:06 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
    On 6/9/22 12:54 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 11:34 AM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
    On 6/9/22 11:47 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void P(u32 x) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
         if (H(x, x)) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>        HERE: goto HERE; >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>      return; >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }

    int main()
    {
         P(P); >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }

    _P()
    [000012e7](01)  55              push
    ebp [000012e8](02)  8bec >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp [000012ea](03)  8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08] [000012ed](01)  50 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push eax [000012ee](03)  8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08] [000012f1](01)  51 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ecx [000012f2](05)  e880feffff >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> call 00001177 // call H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f7](03) 83c408 add esp,+08 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012fa](02)  85c0 test eax,eax >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012fc](02)  7402 jz 00001300 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012fe](02)  ebfe jmp 000012fe >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001300](01)  5d pop ebp >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001301](01)  c3 ret Size in >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> bytes:(0027) [00001301] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    _main()
    [00001307](01)  55              push
    ebp [00001308](02)  8bec >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp [0000130a](05) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 68e7120000 push 000012e7 // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000130f](05) e8d3ffffff call >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 000012e7 // call P [00001314](03) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 83c404 add esp,+04 [00001317](02) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 33c0 xor eax,eax [00001319](01)  5d >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pop ebp [0000131a](01) c3 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>   ret Size in bytes:(0020) [0000131a] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
        machine   stack     stack >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine assembly address   address >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> data code language ========  ======== >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ======== ========= ============= >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001307][00102190][00000000] 55 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp
    [00001308][00102190][00000000] 8bec >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp
    [0000130a][0010218c][000012e7] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 68e7120000 push 000012e7 // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000130f][00102188][00001314] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e8d3ffffff call 000012e7 // call P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e7][00102184][00102190] 55 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp // enter executed P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e8][00102184][00102190] 8bec >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp
    [000012ea][00102184][00102190] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4508 mov eax,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ed][00102180][000012e7] 50 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push eax // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ee][00102180][000012e7] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f1][0010217c][000012e7] 51 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ecx // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f2][00102178][000012f7] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    Begin Local Halt Decider Simulation >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Execution Trace Stored >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> at:212244
    [000012e7][00212230][00212234] 55 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp // enter emulated P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e8][00212230][00212234] 8bec >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp
    [000012ea][00212230][00212234] 8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ed][0021222c][000012e7] 50 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push eax      // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ee][0021222c][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f1][00212228][000012e7] 51 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ecx // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f2][00212224][000012f7] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    So, by what instruction reference >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> manual is a call 00001177 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> followedby the execution of the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instruction at 000012e7. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    Your "CPU" is broken, or emulation >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect.

    FAIL.
    [000012e7][0025cc58][0025cc5c] 55 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp      // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> enter emulated P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e8][0025cc58][0025cc5c] 8bec >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp
    [000012ea][0025cc58][0025cc5c] 8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ed][0025cc54][000012e7] 50 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push eax      // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ee][0025cc54][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f1][0025cc50][000012e7] 51 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ecx // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f2][0025cc4c][000012f7] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Local Halt Decider: Infinite >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Recursion Detected Simulation Stopped >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    It is completely obvious that when >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) correctly emulates >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input that it must emulate the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> first seven instructions of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P. Because the seventh instruction >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of P repeats this process we >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> know with complete certainty that the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulation of P by H would never reach >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its final “ret” instruction, thus >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never halts. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    Problem, the 7th intruction DOESN't >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "Just repeat the procedure", >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because that H always has the option >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to abort its simulation, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just like this onne did, and return to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its P and see it halt. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THAT YOU ARE SIMPLY TOO STUPID TO >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UNDERSTAND THIS IS NO ACTUAL >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> REBUTTAL AT ALL: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    The partial correct x86 emulation of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input to H(P,P) conclusively >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proves that the complete and correct >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> x86 emulation would never stop running. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    You SAY that, but you don't answer the >>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual questions about HOW. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
    THAT YOU ARE SIMPLY TOO STUPID TO >>>>>>>>>>>>>>>>>>>>>>>>>>>> UNDERSTAND THIS IS NO EVIDENCE >>>>>>>>>>>>>>>>>>>>>>>>>>>> WHAT-SO-EVER THAT I DID NOT COMPLETELY >>>>>>>>>>>>>>>>>>>>>>>>>>>> PROVE THAT THE CORRECT >>>>>>>>>>>>>>>>>>>>>>>>>>>> PARTIAL EMULATION OF THE INPUT TO H(P,P) >>>>>>>>>>>>>>>>>>>>>>>>>>>> CONCLUSIVELY PROVES THAT >>>>>>>>>>>>>>>>>>>>>>>>>>>> THE CORRECT AND COMPLETE X86 EMULATION OF >>>>>>>>>>>>>>>>>>>>>>>>>>>> THE INPUT TO H(P,P)
    WOULD NEVER STOP RUNNING. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
    It is completely obvious that when H(P,P) >>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly emulates its >>>>>>>>>>>>>>>>>>>>>>>>>>>> input that it must emulate the first >>>>>>>>>>>>>>>>>>>>>>>>>>>> seven instructions of P. >>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the seventh instruction of P >>>>>>>>>>>>>>>>>>>>>>>>>>>> repeats this process we know >>>>>>>>>>>>>>>>>>>>>>>>>>>> with complete certainty that the correct >>>>>>>>>>>>>>>>>>>>>>>>>>>> and complete emulation of >>>>>>>>>>>>>>>>>>>>>>>>>>>> P by H would never reach its final “ret” >>>>>>>>>>>>>>>>>>>>>>>>>>>> instruction, thus never >>>>>>>>>>>>>>>>>>>>>>>>>>>> halts.

    If P should have halted (i.e. no infinite >>>>>>>>>>>>>>>>>>>>>>>>>>> loop) then your simulation >>>>>>>>>>>>>>>>>>>>>>>>>>> detector, S (not H), gets the answer >>>>>>>>>>>>>>>>>>>>>>>>>>> wrong. You S is NOT a halting >>>>>>>>>>>>>>>>>>>>>>>>>>> decider.

    /Flibble

    THAT YOU ARE SIMPLY TOO STUPID TO >>>>>>>>>>>>>>>>>>>>>>>>>> UNDERSTAND THIS IS NO ACTUAL >>>>>>>>>>>>>>>>>>>>>>>>>> REBUTTAL AT ALL.

    _P()
    [00001352](01)  55              push ebp
    [00001353](02)  8bec            mov ebp,esp
    [00001355](03)  8b4508          mov >>>>>>>>>>>>>>>>>>>>>>>>>> eax,[ebp+08] [00001358](01)  50 >>>>>>>>>>>>>>>>>>>>>>>>>> push eax      // push P [00001359](03) >>>>>>>>>>>>>>>>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08] [0000135c](01)  51 >>>>>>>>>>>>>>>>>>>>>>>>>>            push ecx      // push P
    [0000135d](05)  e840feffff call 000011a2 // >>>>>>>>>>>>>>>>>>>>>>>>>> call H [00001362](03)  83c408 add esp,+08 >>>>>>>>>>>>>>>>>>>>>>>>>> [00001365](02)  85c0 test eax,eax >>>>>>>>>>>>>>>>>>>>>>>>>> [00001367](02)  7402            jz 0000136b
    [00001369](02)  ebfe            jmp >>>>>>>>>>>>>>>>>>>>>>>>>> 00001369 [0000136b](01)  5d >>>>>>>>>>>>>>>>>>>>>>>>>> pop ebp [0000136c](01)  c3 >>>>>>>>>>>>>>>>>>>>>>>>>> ret Size in bytes:(0027) [0000136c] >>>>>>>>>>>>>>>>>>>>>>>>>>
    It is completely obvious that when H(P,P) >>>>>>>>>>>>>>>>>>>>>>>>>> correctly emulates its
    input that it must emulate the first seven >>>>>>>>>>>>>>>>>>>>>>>>>> instructions of P. Because >>>>>>>>>>>>>>>>>>>>>>>>>> the seventh instruction of P repeats this >>>>>>>>>>>>>>>>>>>>>>>>>> process we know with
    complete certainty that the correct and >>>>>>>>>>>>>>>>>>>>>>>>>> complete emulation of P by H >>>>>>>>>>>>>>>>>>>>>>>>>> would never reach its final “ret” >>>>>>>>>>>>>>>>>>>>>>>>>> instruction, thus never halts. >>>>>>>>>>>>>>>>>>>>>>>>>
    We are going around and around and around in >>>>>>>>>>>>>>>>>>>>>>>>> circles. I will try again: >>>>>>>>>>>>>>>>>>>>>>>>>
    If you replace the opcodes "EB FE" at >>>>>>>>>>>>>>>>>>>>>>>>> 00001369 with the opcodes "90 90" >>>>>>>>>>>>>>>>>>>>>>>>> then your H gets the answer wrong: P should >>>>>>>>>>>>>>>>>>>>>>>>> have halted.

    /Flibble


    As I already said before this is merely your >>>>>>>>>>>>>>>>>>>>>>>> cluelessness that when H(P,P) is invoked the >>>>>>>>>>>>>>>>>>>>>>>> correct x86 emulation of the input to H(P,P) >>>>>>>>>>>>>>>>>>>>>>>> makes and code after [0000135d] unreachable. >>>>>>>>>>>>>>>>>>>>>>>>

    Wrong, because when that H return the value 0, >>>>>>>>>>>>>>>>>>>>>>> it will get there.
    Like I said people that are dumber than a box >>>>>>>>>>>>>>>>>>>>>> of rocks won't be able to correctly understand >>>>>>>>>>>>>>>>>>>>>> this.

    When H(P,P) is invoked the correctly emulated >>>>>>>>>>>>>>>>>>>>>> input to H(P,P) cannot possibly reach any >>>>>>>>>>>>>>>>>>>>>> instruction beyond [0000135d].

    So, you are defining that you H(P,P) never >>>>>>>>>>>>>>>>>>>>> returns because it is caught in the infinite >>>>>>>>>>>>>>>>>>>>> rcursion.

    Thats fine, just says it can't be the correctly >>>>>>>>>>>>>>>>>>>>> answering decider you claim it to be. >>>>>>>>>>>>>>>>>>>>
    I have corrected you on this too many times. >>>>>>>>>>>>>>>>>>>>

    How. You need to define what H(P,P) actually >>>>>>>>>>>>>>>>>>> does.

    I have explained that too many times.

    To understand that H(P,P)==0 is correct we only >>>>>>>>>>>>>>>>>> need to know that H performs a correct x86 >>>>>>>>>>>>>>>>>> emulation of its input and then examine the >>>>>>>>>>>>>>>>>> execution trace.

    And a CORRECT emulation of the code will Halt if >>>>>>>>>>>>>>>>> H(P,P) returns 0, which it can only do if it does >>>>>>>>>>>>>>>>> not actually do a correct emulation

    The correctly emulated input to H(P,P) never gets >>>>>>>>>>>>>>>> past its machine address [0000135d].



    Only if H actually doesn't return 0. Yes, H can't >>>>>>>>>>>>>>> correctly return 0 if it correctly emulates its input, >>>>>>>>>>>>>>> but you can't drop that requirement.

    void P(u32 x)
    {
       if (H(x, x))
         HERE: goto HERE;
       return;
    }

    int main()
    {
       Output("Input_Halts = ", H((u32)P, (u32)P)); >>>>>>>>>>>>>> }

    When H returns 0 it does not returns 0 to P it returns >>>>>>>>>>>>>> 0 to main().

    But it also return 0 to the computation P(P), maybe not >>>>>>>>>>>>> the copy that it is simulating, since it aborts that >>>>>>>>>>>>> before it get to it,

    Finally you are not stupid or deceptive.

    If H never returns a value to P then H is not a halting >>>>>>>>>>> decider; if H returns a value of 0 to main() when P halts >>>>>>>>>>> then H is not a halting decider.

    H is not a halting decider; H is a simulation detector, S. >>>>>>>>>>>
    /Flibble


    In other words you are saying the infintely nested
    emulation only excutes for a few steps and then it stops >>>>>>>>>> on its own.

    I am saying that your H is not a halting decider; I am
    saying that your H is just a simulation detector, S.

    /Flibble


    You are saying that you simply "don't believe in" simulating >>>>>>>> halt deciders.

    You haven't got a simulating halt decider, what you have got
    is a simulation detector.

    /Flibble


    It is an easily verified fact that H does correctly decide the
    halt status of its input.

    void Infinite_Loop()
    {
    HERE: goto HERE;
    }

    int main()
    {
    Output("Input_Halts = ", H0(Infinite_Loop));
    }

    _Infinite_Loop()
    [00001342](01) 55 push ebp
    [00001343](02) 8bec mov ebp,esp
    [00001345](02) ebfe jmp 00001345
    [00001347](01) 5d pop ebp
    [00001348](01) c3 ret
    Size in bytes:(0007) [00001348]

    _main()
    [00001372](01) 55 push ebp
    [00001373](02) 8bec mov ebp,esp
    [00001375](05) 6842130000 push 00001342
    [0000137a](05) e833fdffff call 000010b2
    [0000137f](03) 83c404 add esp,+04
    [00001382](01) 50 push eax
    [00001383](05) 6823040000 push 00000423
    [00001388](05) e8e5f0ffff call 00000472
    [0000138d](03) 83c408 add esp,+08
    [00001390](02) 33c0 xor eax,eax
    [00001392](01) 5d pop ebp
    [00001393](01) c3 ret
    Size in bytes:(0034) [00001393]

    machine stack stack machine assembly
    address address data code language
    ======== ======== ======== ========= =============
    [00001372][0010228f][00000000] 55 push ebp
    [00001373][0010228f][00000000] 8bec mov ebp,esp
    [00001375][0010228b][00001342] 6842130000 push 00001342 // push
    _Infinite_Loop
    [0000137a][00102287][0000137f] e833fdffff call 000010b2 // call
    H0

    Begin Local Halt Decider Simulation Execution Trace Stored
    at:212343 [00001342][00212333][00212337] 55 push ebp
    [00001343][00212333][00212337] 8bec mov ebp,esp
    [00001345][00212333][00212337] ebfe jmp 00001345
    [00001345][00212333][00212337] ebfe jmp 00001345
    Local Halt Decider: Infinite Loop Detected Simulation Stopped

    [0000137f][0010228f][00000000] 83c404 add esp,+04
    [00001382][0010228b][00000000] 50 push eax
    [00001383][00102287][00000423] 6823040000 push 00000423
    [00001388][00102287][00000423] e8e5f0ffff call 00000472
    Input_Halts = 0
    [0000138d][0010228f][00000000] 83c408 add esp,+08
    [00001390][0010228f][00000000] 33c0 xor eax,eax
    [00001392][00102293][00100000] 5d pop ebp
    [00001393][00102297][00000004] c3 ret
    Number of Instructions Executed(680)

    int Sum(int X, int Y)
    {
    return X + Y;
    }

    int main()
    {
    Output("Input_Halts = ", H2(Sum, 3, 4));
    }

    _Sum()
    [000012b6](01) 55 push ebp
    [000012b7](02) 8bec mov ebp,esp
    [000012b9](03) 8b4508 mov eax,[ebp+08]
    [000012bc](03) 03450c add eax,[ebp+0c]
    [000012bf](01) 5d pop ebp
    [000012c0](01) c3 ret
    Size in bytes:(0011) [000012c0]

    _main()
    [00001316](01) 55 push ebp
    [00001317](02) 8bec mov ebp,esp
    [00001319](02) 6a04 push +04
    [0000131b](02) 6a03 push +03
    [0000131d](05) 68b6120000 push 000012b6
    [00001322](05) e85ffaffff call 00000d86
    [00001327](03) 83c40c add esp,+0c
    [0000132a](01) 50 push eax
    [0000132b](05) 6807040000 push 00000407
    [00001330](05) e821f1ffff call 00000456
    [00001335](03) 83c408 add esp,+08
    [00001338](02) 33c0 xor eax,eax
    [0000133a](01) 5d pop ebp
    [0000133b](01) c3 ret
    Size in bytes:(0038) [0000133b]

    machine stack stack machine assembly
    address address data code language
    ======== ======== ======== ========= =============
    ...[00001316][001021d7][00000000] 55 push ebp
    ...[00001317][001021d7][00000000] 8bec mov ebp,esp
    ...[00001319][001021d3][00000004] 6a04 push +04
    ...[0000131b][001021cf][00000003] 6a03 push +03
    ...[0000131d][001021cb][000012b6] 68b6120000 push 000012b6
    ...[00001322][001021c7][00001327] e85ffaffff call 00000d86

    Begin Local Halt Decider Simulation Execution Trace Stored
    at:21228b ...[000012b6][00212273][00212277] 55
    push ebp ...[000012b7][00212273][00212277] 8bec mov
    ebp,esp ...[000012b9][00212273][00212277] 8b4508 mov
    eax,[ebp+08] ...[000012bc][00212273][00212277] 03450c
    add eax,[ebp+0c] ...[000012bf][00212277][00000e54] 5d
    pop ebp ...[000012c0][0021227b][00000003] c3
    ret ...[00001327][001021d7][00000000] 83c40c add
    esp,+0c ...[0000132a][001021d3][00000001] 50 push
    eax ...[0000132b][001021cf][00000407] 6807040000 push
    00000407 ---[00001330][001021cf][00000407] e821f1ffff
    call 00000456 Input_Halts = 1
    ...[00001335][001021d7][00000000] 83c408 add esp,+08
    ...[00001338][001021d7][00000000] 33c0 xor eax,eax
    ...[0000133a][001021db][00100000] 5d pop ebp
    ...[0000133b][001021df][00000004] c3 ret
    Number of Instructions Executed(660)

    All you are showing here is that your H can decide the halt
    status of two trivial cases however you have not shown that H
    can decide the halt status of non-trivial cases.


    You said:
    "You haven't got a simulating halt decider"
    Apologize and we can move on.

    I posted four paragraphs but you ignored three of them. Lets try
    again.

    IF YOU DON'T APOLOGIZE THEN WE CANNOT MOVE ON !!!

    It seems I need to try again. Perhaps it will help if I combine the
    four paragraphs into a single paragraph:

    All you are showing here is that your H can decide the halt status
    of two trivial cases however you have not shown that H can decide
    the halt status of non-trivial cases.

    H is a halt decider for a subset of its inputs.
    H is a halt decider for P.
    When H is a halt decider for P all of the conventional halting
    problem proofs have been refuted.

    For H to be a halt decider it needs to be a halt decider for all inputs
    not a subset.


    Publish the source code of your halt
    decider so we can see what classes of programs your H can decide. I
    am interested in deciding the halt status of programs containing non-trivial branching logic predicated on arbitrary program input.

    These are out-of-scope.

    You may assert this but that doesn't make your assertion true. If they
    are out-of-scope then your H is out of scope of the Halting Problem.


    Crucially if your H cannot return an answer for an arbitrary
    non-halting program in finite time then it isn't a halt decider.

    One can either say that H is a halt decider for a subset of its
    inputs or that H is a halt determiner. As long as H(P,P) correctly
    decides its input all of the conventional HP proofs have been refuted.

    If we are to make progress you need to publish the code of your
    infinite loop detector. I suspect that you refuse to do this as you
    know it is either a trivial pattern matcher or relies on machine state
    (i.e. CPU registers and RAM) being unchanged during emulation of a
    program loop which is an naively erroneous approach.

    /Flibble

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Mr Flibble on Fri Jun 10 08:59:17 2022
    XPost: comp.theory, sci.logic, sci.math

    On 6/10/2022 8:51 AM, Mr Flibble wrote:
    On Fri, 10 Jun 2022 08:43:48 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/10/2022 8:35 AM, Mr Flibble wrote:
    On Fri, 10 Jun 2022 08:33:27 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/10/2022 8:29 AM, Mr Flibble wrote:
    On Fri, 10 Jun 2022 08:27:28 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/10/2022 8:23 AM, Mr Flibble wrote:
    On Fri, 10 Jun 2022 08:05:57 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/10/2022 6:11 AM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:35:05 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 5:27 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:18:38 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 5:15 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:09:08 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 4:54 PM, Richard Damon wrote:
    On 6/9/22 5:29 PM, olcott wrote:
    On 6/9/2022 4:13 PM, Richard Damon wrote:

    On 6/9/22 5:00 PM, olcott wrote:
    On 6/9/2022 3:25 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 6/9/22 4:13 PM, olcott wrote:
    On 6/9/2022 2:57 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 6/9/22 3:52 PM, olcott wrote:
    On 6/9/2022 2:38 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>
    On 6/9/22 3:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 1:12 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 1:55 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 12:46 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 12:39:32 -0500 >>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>
    On 6/9/2022 12:28 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 12:15:24 -0500 >>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 12:06 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
    On 6/9/22 12:54 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 11:34 AM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
    On 6/9/22 11:47 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void P(u32 x) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
         if (H(x, x)) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>        HERE: goto HERE; >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>      return; >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }

    int main() >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
         P(P); >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }

    _P()
    [000012e7](01)  55              push
    ebp [000012e8](02)  8bec >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp [000012ea](03)  8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08] [000012ed](01)  50 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push eax [000012ee](03)  8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08] [000012f1](01)  51 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ecx [000012f2](05)  e880feffff >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> call 00001177 // call H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f7](03) 83c408 add esp,+08 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012fa](02)  85c0 test eax,eax >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012fc](02)  7402 jz 00001300 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012fe](02)  ebfe jmp 000012fe >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001300](01)  5d pop ebp >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001301](01)  c3 ret Size in >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> bytes:(0027) [00001301] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    _main()
    [00001307](01)  55              push
    ebp [00001308](02)  8bec >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp [0000130a](05) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 68e7120000 push 000012e7 // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000130f](05) e8d3ffffff call >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 000012e7 // call P [00001314](03) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 83c404 add esp,+04 [00001317](02) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 33c0 xor eax,eax [00001319](01)  5d >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pop ebp [0000131a](01) c3 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>   ret Size in bytes:(0020) [0000131a] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
        machine   stack     stack
    machine assembly address   address >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> data code language ========  ======== >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ======== ========= ============= >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001307][00102190][00000000] 55 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp
    [00001308][00102190][00000000] 8bec >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000130a][0010218c][000012e7] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 68e7120000 push 000012e7 // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000130f][00102188][00001314] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e8d3ffffff call 000012e7 // call P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e7][00102184][00102190] 55 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp // enter executed P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e8][00102184][00102190] 8bec >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ea][00102184][00102190] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4508 mov eax,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ed][00102180][000012e7] 50 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push eax // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ee][00102180][000012e7] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f1][0010217c][000012e7] 51 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ecx // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f2][00102178][000012f7] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    Begin Local Halt Decider Simulation >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Execution Trace Stored >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> at:212244
    [000012e7][00212230][00212234] 55 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp // enter emulated P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e8][00212230][00212234] 8bec >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ea][00212230][00212234] 8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ed][0021222c][000012e7] 50 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push eax      // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ee][0021222c][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f1][00212228][000012e7] 51 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ecx // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f2][00212224][000012f7] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    So, by what instruction reference >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> manual is a call 00001177 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> followedby the execution of the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instruction at 000012e7. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    Your "CPU" is broken, or emulation >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect.

    FAIL.
    [000012e7][0025cc58][0025cc5c] 55 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp      // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> enter emulated P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e8][0025cc58][0025cc5c] 8bec >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ea][0025cc58][0025cc5c] 8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ed][0025cc54][000012e7] 50 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push eax      // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ee][0025cc54][000012e7] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f1][0025cc50][000012e7] 51 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ecx // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f2][0025cc4c][000012f7] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Local Halt Decider: Infinite >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Recursion Detected Simulation Stopped >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    It is completely obvious that when >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) correctly emulates >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input that it must emulate the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> first seven instructions of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P. Because the seventh instruction >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of P repeats this process we >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> know with complete certainty that the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulation of P by H would never reach >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its final “ret” instruction, thus >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never halts. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    Problem, the 7th intruction DOESN't >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "Just repeat the procedure", >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because that H always has the option >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to abort its simulation, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just like this onne did, and return to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its P and see it halt. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THAT YOU ARE SIMPLY TOO STUPID TO >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UNDERSTAND THIS IS NO ACTUAL >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> REBUTTAL AT ALL: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    The partial correct x86 emulation of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input to H(P,P) conclusively >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proves that the complete and correct >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> x86 emulation would never stop running. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

    You SAY that, but you don't answer the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual questions about HOW. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    THAT YOU ARE SIMPLY TOO STUPID TO >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UNDERSTAND THIS IS NO EVIDENCE >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WHAT-SO-EVER THAT I DID NOT COMPLETELY >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PROVE THAT THE CORRECT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PARTIAL EMULATION OF THE INPUT TO H(P,P) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> CONCLUSIVELY PROVES THAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THE CORRECT AND COMPLETE X86 EMULATION OF >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THE INPUT TO H(P,P) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WOULD NEVER STOP RUNNING. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    It is completely obvious that when H(P,P) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly emulates its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input that it must emulate the first >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> seven instructions of P. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the seventh instruction of P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeats this process we know >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> with complete certainty that the correct >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and complete emulation of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P by H would never reach its final “ret” >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instruction, thus never >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts.

    If P should have halted (i.e. no infinite >>>>>>>>>>>>>>>>>>>>>>>>>>>>> loop) then your simulation >>>>>>>>>>>>>>>>>>>>>>>>>>>>> detector, S (not H), gets the answer >>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong. You S is NOT a halting >>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider.

    /Flibble

    THAT YOU ARE SIMPLY TOO STUPID TO >>>>>>>>>>>>>>>>>>>>>>>>>>>> UNDERSTAND THIS IS NO ACTUAL >>>>>>>>>>>>>>>>>>>>>>>>>>>> REBUTTAL AT ALL.

    _P()
    [00001352](01)  55              push ebp
    [00001353](02)  8bec            mov ebp,esp
    [00001355](03)  8b4508          mov >>>>>>>>>>>>>>>>>>>>>>>>>>>> eax,[ebp+08] [00001358](01)  50 >>>>>>>>>>>>>>>>>>>>>>>>>>>> push eax      // push P [00001359](03) >>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08] [0000135c](01)  51 >>>>>>>>>>>>>>>>>>>>>>>>>>>>            push ecx      // push P
    [0000135d](05)  e840feffff call 000011a2 // >>>>>>>>>>>>>>>>>>>>>>>>>>>> call H [00001362](03)  83c408 add esp,+08 >>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001365](02)  85c0 test eax,eax >>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001367](02)  7402            jz 0000136b
    [00001369](02)  ebfe            jmp >>>>>>>>>>>>>>>>>>>>>>>>>>>> 00001369 [0000136b](01)  5d >>>>>>>>>>>>>>>>>>>>>>>>>>>> pop ebp [0000136c](01)  c3 >>>>>>>>>>>>>>>>>>>>>>>>>>>> ret Size in bytes:(0027) [0000136c] >>>>>>>>>>>>>>>>>>>>>>>>>>>>
    It is completely obvious that when H(P,P) >>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly emulates its >>>>>>>>>>>>>>>>>>>>>>>>>>>> input that it must emulate the first seven >>>>>>>>>>>>>>>>>>>>>>>>>>>> instructions of P. Because >>>>>>>>>>>>>>>>>>>>>>>>>>>> the seventh instruction of P repeats this >>>>>>>>>>>>>>>>>>>>>>>>>>>> process we know with
    complete certainty that the correct and >>>>>>>>>>>>>>>>>>>>>>>>>>>> complete emulation of P by H >>>>>>>>>>>>>>>>>>>>>>>>>>>> would never reach its final “ret” >>>>>>>>>>>>>>>>>>>>>>>>>>>> instruction, thus never halts. >>>>>>>>>>>>>>>>>>>>>>>>>>>
    We are going around and around and around in >>>>>>>>>>>>>>>>>>>>>>>>>>> circles. I will try again: >>>>>>>>>>>>>>>>>>>>>>>>>>>
    If you replace the opcodes "EB FE" at >>>>>>>>>>>>>>>>>>>>>>>>>>> 00001369 with the opcodes "90 90" >>>>>>>>>>>>>>>>>>>>>>>>>>> then your H gets the answer wrong: P should >>>>>>>>>>>>>>>>>>>>>>>>>>> have halted.

    /Flibble


    As I already said before this is merely your >>>>>>>>>>>>>>>>>>>>>>>>>> cluelessness that when H(P,P) is invoked the >>>>>>>>>>>>>>>>>>>>>>>>>> correct x86 emulation of the input to H(P,P) >>>>>>>>>>>>>>>>>>>>>>>>>> makes and code after [0000135d] unreachable. >>>>>>>>>>>>>>>>>>>>>>>>>>

    Wrong, because when that H return the value 0, >>>>>>>>>>>>>>>>>>>>>>>>> it will get there.
    Like I said people that are dumber than a box >>>>>>>>>>>>>>>>>>>>>>>> of rocks won't be able to correctly understand >>>>>>>>>>>>>>>>>>>>>>>> this.

    When H(P,P) is invoked the correctly emulated >>>>>>>>>>>>>>>>>>>>>>>> input to H(P,P) cannot possibly reach any >>>>>>>>>>>>>>>>>>>>>>>> instruction beyond [0000135d].

    So, you are defining that you H(P,P) never >>>>>>>>>>>>>>>>>>>>>>> returns because it is caught in the infinite >>>>>>>>>>>>>>>>>>>>>>> rcursion.

    Thats fine, just says it can't be the correctly >>>>>>>>>>>>>>>>>>>>>>> answering decider you claim it to be. >>>>>>>>>>>>>>>>>>>>>>
    I have corrected you on this too many times. >>>>>>>>>>>>>>>>>>>>>>

    How. You need to define what H(P,P) actually >>>>>>>>>>>>>>>>>>>>> does.

    I have explained that too many times.

    To understand that H(P,P)==0 is correct we only >>>>>>>>>>>>>>>>>>>> need to know that H performs a correct x86 >>>>>>>>>>>>>>>>>>>> emulation of its input and then examine the >>>>>>>>>>>>>>>>>>>> execution trace.

    And a CORRECT emulation of the code will Halt if >>>>>>>>>>>>>>>>>>> H(P,P) returns 0, which it can only do if it does >>>>>>>>>>>>>>>>>>> not actually do a correct emulation

    The correctly emulated input to H(P,P) never gets >>>>>>>>>>>>>>>>>> past its machine address [0000135d].



    Only if H actually doesn't return 0. Yes, H can't >>>>>>>>>>>>>>>>> correctly return 0 if it correctly emulates its input, >>>>>>>>>>>>>>>>> but you can't drop that requirement.

    void P(u32 x)
    {
       if (H(x, x))
         HERE: goto HERE;
       return;
    }

    int main()
    {
       Output("Input_Halts = ", H((u32)P, (u32)P)); >>>>>>>>>>>>>>>> }

    When H returns 0 it does not returns 0 to P it returns >>>>>>>>>>>>>>>> 0 to main().

    But it also return 0 to the computation P(P), maybe not >>>>>>>>>>>>>>> the copy that it is simulating, since it aborts that >>>>>>>>>>>>>>> before it get to it,

    Finally you are not stupid or deceptive.

    If H never returns a value to P then H is not a halting >>>>>>>>>>>>> decider; if H returns a value of 0 to main() when P halts >>>>>>>>>>>>> then H is not a halting decider.

    H is not a halting decider; H is a simulation detector, S. >>>>>>>>>>>>>
    /Flibble


    In other words you are saying the infintely nested
    emulation only excutes for a few steps and then it stops >>>>>>>>>>>> on its own.

    I am saying that your H is not a halting decider; I am
    saying that your H is just a simulation detector, S.

    /Flibble


    You are saying that you simply "don't believe in" simulating >>>>>>>>>> halt deciders.

    You haven't got a simulating halt decider, what you have got >>>>>>>>> is a simulation detector.

    /Flibble


    It is an easily verified fact that H does correctly decide the >>>>>>>> halt status of its input.

    void Infinite_Loop()
    {
    HERE: goto HERE;
    }

    int main()
    {
    Output("Input_Halts = ", H0(Infinite_Loop));
    }

    _Infinite_Loop()
    [00001342](01) 55 push ebp
    [00001343](02) 8bec mov ebp,esp
    [00001345](02) ebfe jmp 00001345
    [00001347](01) 5d pop ebp
    [00001348](01) c3 ret
    Size in bytes:(0007) [00001348]

    _main()
    [00001372](01) 55 push ebp
    [00001373](02) 8bec mov ebp,esp
    [00001375](05) 6842130000 push 00001342
    [0000137a](05) e833fdffff call 000010b2
    [0000137f](03) 83c404 add esp,+04
    [00001382](01) 50 push eax
    [00001383](05) 6823040000 push 00000423
    [00001388](05) e8e5f0ffff call 00000472
    [0000138d](03) 83c408 add esp,+08
    [00001390](02) 33c0 xor eax,eax
    [00001392](01) 5d pop ebp
    [00001393](01) c3 ret
    Size in bytes:(0034) [00001393]

    machine stack stack machine assembly
    address address data code language
    ======== ======== ======== ========= =============
    [00001372][0010228f][00000000] 55 push ebp
    [00001373][0010228f][00000000] 8bec mov ebp,esp
    [00001375][0010228b][00001342] 6842130000 push 00001342 // push >>>>>>>> _Infinite_Loop
    [0000137a][00102287][0000137f] e833fdffff call 000010b2 // call >>>>>>>> H0

    Begin Local Halt Decider Simulation Execution Trace Stored
    at:212343 [00001342][00212333][00212337] 55 push ebp
    [00001343][00212333][00212337] 8bec mov ebp,esp
    [00001345][00212333][00212337] ebfe jmp 00001345
    [00001345][00212333][00212337] ebfe jmp 00001345
    Local Halt Decider: Infinite Loop Detected Simulation Stopped

    [0000137f][0010228f][00000000] 83c404 add esp,+04
    [00001382][0010228b][00000000] 50 push eax
    [00001383][00102287][00000423] 6823040000 push 00000423
    [00001388][00102287][00000423] e8e5f0ffff call 00000472
    Input_Halts = 0
    [0000138d][0010228f][00000000] 83c408 add esp,+08
    [00001390][0010228f][00000000] 33c0 xor eax,eax
    [00001392][00102293][00100000] 5d pop ebp
    [00001393][00102297][00000004] c3 ret
    Number of Instructions Executed(680)

    int Sum(int X, int Y)
    {
    return X + Y;
    }

    int main()
    {
    Output("Input_Halts = ", H2(Sum, 3, 4));
    }

    _Sum()
    [000012b6](01) 55 push ebp
    [000012b7](02) 8bec mov ebp,esp
    [000012b9](03) 8b4508 mov eax,[ebp+08]
    [000012bc](03) 03450c add eax,[ebp+0c]
    [000012bf](01) 5d pop ebp
    [000012c0](01) c3 ret
    Size in bytes:(0011) [000012c0]

    _main()
    [00001316](01) 55 push ebp
    [00001317](02) 8bec mov ebp,esp
    [00001319](02) 6a04 push +04
    [0000131b](02) 6a03 push +03
    [0000131d](05) 68b6120000 push 000012b6
    [00001322](05) e85ffaffff call 00000d86
    [00001327](03) 83c40c add esp,+0c
    [0000132a](01) 50 push eax
    [0000132b](05) 6807040000 push 00000407
    [00001330](05) e821f1ffff call 00000456
    [00001335](03) 83c408 add esp,+08
    [00001338](02) 33c0 xor eax,eax
    [0000133a](01) 5d pop ebp
    [0000133b](01) c3 ret
    Size in bytes:(0038) [0000133b]

    machine stack stack machine assembly
    address address data code language
    ======== ======== ======== ========= =============
    ...[00001316][001021d7][00000000] 55 push ebp
    ...[00001317][001021d7][00000000] 8bec mov ebp,esp
    ...[00001319][001021d3][00000004] 6a04 push +04
    ...[0000131b][001021cf][00000003] 6a03 push +03
    ...[0000131d][001021cb][000012b6] 68b6120000 push 000012b6 >>>>>>>> ...[00001322][001021c7][00001327] e85ffaffff call 00000d86 >>>>>>>>
    Begin Local Halt Decider Simulation Execution Trace Stored
    at:21228b ...[000012b6][00212273][00212277] 55
    push ebp ...[000012b7][00212273][00212277] 8bec mov >>>>>>>> ebp,esp ...[000012b9][00212273][00212277] 8b4508 mov
    eax,[ebp+08] ...[000012bc][00212273][00212277] 03450c
    add eax,[ebp+0c] ...[000012bf][00212277][00000e54] 5d
    pop ebp ...[000012c0][0021227b][00000003] c3
    ret ...[00001327][001021d7][00000000] 83c40c add
    esp,+0c ...[0000132a][001021d3][00000001] 50 push >>>>>>>> eax ...[0000132b][001021cf][00000407] 6807040000 push
    00000407 ---[00001330][001021cf][00000407] e821f1ffff
    call 00000456 Input_Halts = 1
    ...[00001335][001021d7][00000000] 83c408 add esp,+08
    ...[00001338][001021d7][00000000] 33c0 xor eax,eax
    ...[0000133a][001021db][00100000] 5d pop ebp
    ...[0000133b][001021df][00000004] c3 ret
    Number of Instructions Executed(660)

    All you are showing here is that your H can decide the halt
    status of two trivial cases however you have not shown that H
    can decide the halt status of non-trivial cases.


    You said:
    "You haven't got a simulating halt decider"
    Apologize and we can move on.

    I posted four paragraphs but you ignored three of them. Lets try
    again.

    IF YOU DON'T APOLOGIZE THEN WE CANNOT MOVE ON !!!

    It seems I need to try again. Perhaps it will help if I combine the
    four paragraphs into a single paragraph:

    All you are showing here is that your H can decide the halt status
    of two trivial cases however you have not shown that H can decide
    the halt status of non-trivial cases.

    H is a halt decider for a subset of its inputs.
    H is a halt decider for P.
    When H is a halt decider for P all of the conventional halting
    problem proofs have been refuted.

    For H to be a halt decider it needs to be a halt decider for all inputs
    not a subset.


    Publish the source code of your halt
    decider so we can see what classes of programs your H can decide. I
    am interested in deciding the halt status of programs containing
    non-trivial branching logic predicated on arbitrary program input.

    These are out-of-scope.

    You may assert this but that doesn't make your assertion true. If they
    are out-of-scope then your H is out of scope of the Halting Problem.


    Crucially if your H cannot return an answer for an arbitrary
    non-halting program in finite time then it isn't a halt decider.

    One can either say that H is a halt decider for a subset of its
    inputs or that H is a halt determiner. As long as H(P,P) correctly
    decides its input all of the conventional HP proofs have been refuted.

    If we are to make progress you need to publish the code of your
    infinite loop detector.

    If you can't understand 14 lines of code then this conclusively proves
    that you won't understand hundreds of pages of code.

    Because people here are only interested in rebuttal and don't give a
    rat's ass about an honest dialogue I make the price of a continued
    dialogue key points of mutual agreement.

    If you don't understand that H(P,P)==0 is correct then providing the
    source code will only provide the means for denigration based on lack of comprehension. I absolutely will not tolerate that.

    I suspect that you refuse to do this as you
    know it is either a trivial pattern matcher or relies on machine state
    (i.e. CPU registers and RAM) being unchanged during emulation of a
    program loop which is an naively erroneous approach.

    /Flibble



    --
    Copyright 2022 Pete Olcott

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

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mr Flibble@21:1/5 to olcott on Fri Jun 10 15:03:18 2022
    XPost: comp.theory, sci.logic, sci.math

    On Fri, 10 Jun 2022 08:59:17 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/10/2022 8:51 AM, Mr Flibble wrote:
    On Fri, 10 Jun 2022 08:43:48 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/10/2022 8:35 AM, Mr Flibble wrote:
    On Fri, 10 Jun 2022 08:33:27 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/10/2022 8:29 AM, Mr Flibble wrote:
    On Fri, 10 Jun 2022 08:27:28 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/10/2022 8:23 AM, Mr Flibble wrote:
    On Fri, 10 Jun 2022 08:05:57 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/10/2022 6:11 AM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:35:05 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 5:27 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:18:38 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 5:15 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:09:08 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/9/2022 4:54 PM, Richard Damon wrote:
    On 6/9/22 5:29 PM, olcott wrote:
    On 6/9/2022 4:13 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>
    On 6/9/22 5:00 PM, olcott wrote:
    On 6/9/2022 3:25 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 6/9/22 4:13 PM, olcott wrote:
    On 6/9/2022 2:57 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 6/9/22 3:52 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 2:38 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>
    On 6/9/22 3:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 1:12 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 1:55 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 12:46 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 12:39:32 -0500 >>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 12:28 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 12:15:24 -0500 >>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 12:06 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
    On 6/9/22 12:54 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 11:34 AM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
    On 6/9/22 11:47 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void P(u32 x) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
         if (H(x, x)) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>        HERE: goto HERE; >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>      return; >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }

    int main() >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
         P(P); >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }

    _P()
    [000012e7](01)  55 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp [000012e8](02)  8bec >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp [000012ea](03)  8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08] [000012ed](01)  50 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push eax [000012ee](03)  8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08] [000012f1](01)  51 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ecx [000012f2](05)  e880feffff >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> call 00001177 // call H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f7](03) 83c408 add esp,+08 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012fa](02)  85c0 test eax,eax >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012fc](02)  7402 jz 00001300 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012fe](02)  ebfe jmp 000012fe >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001300](01)  5d pop ebp >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001301](01)  c3 ret Size in >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> bytes:(0027) [00001301] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    _main()
    [00001307](01)  55 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp [00001308](02)  8bec >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp [0000130a](05) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 68e7120000 push 000012e7 // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000130f](05) e8d3ffffff call >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 000012e7 // call P [00001314](03) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 83c404 add esp,+04 [00001317](02) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 33c0 xor eax,eax [00001319](01)  5d >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pop ebp [0000131a](01) c3 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>   ret Size in bytes:(0020) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000131a] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
        machine   stack >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> stack machine assembly address >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> address data code language >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ========  ======== ======== >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ========= ============= >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001307][00102190][00000000] 55 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001308][00102190][00000000] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8bec mov ebp,esp >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000130a][0010218c][000012e7] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 68e7120000 push 000012e7 // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000130f][00102188][00001314] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e8d3ffffff call 000012e7 // call P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e7][00102184][00102190] 55 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp // enter executed P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e8][00102184][00102190] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8bec mov ebp,esp >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ea][00102184][00102190] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4508 mov eax,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ed][00102180][000012e7] 50 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push eax // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ee][00102180][000012e7] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f1][0010217c][000012e7] 51 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ecx // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f2][00102178][000012f7] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    Begin Local Halt Decider Simulation >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Execution Trace Stored >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> at:212244 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e7][00212230][00212234] 55 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp // enter emulated P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e8][00212230][00212234] 8bec >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ea][00212230][00212234] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4508 mov eax,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ed][0021222c][000012e7] 50 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push eax      // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ee][0021222c][000012e7] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f1][00212228][000012e7] 51 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ecx // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f2][00212224][000012f7] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

    So, by what instruction reference >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> manual is a call 00001177 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> followedby the execution of the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instruction at 000012e7. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    Your "CPU" is broken, or emulation >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    FAIL.
    [000012e7][0025cc58][0025cc5c] 55 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp      // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> enter emulated P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e8][0025cc58][0025cc5c] 8bec >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ea][0025cc58][0025cc5c] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4508 mov eax,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ed][0025cc54][000012e7] 50 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push eax      // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ee][0025cc54][000012e7] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f1][0025cc50][000012e7] 51 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ecx // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f2][0025cc4c][000012f7] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call 00001177 // call H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Local Halt Decider: Infinite >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Recursion Detected Simulation >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Stopped

    It is completely obvious that when >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) correctly emulates >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input that it must emulate the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> first seven instructions of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P. Because the seventh instruction >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of P repeats this process we >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> know with complete certainty that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the correct and complete >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulation of P by H would never >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its final “ret” instruction, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> thus never halts. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    Problem, the 7th intruction DOESN't >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "Just repeat the procedure", >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because that H always has the option >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to abort its simulation, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just like this onne did, and return >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to its P and see it halt. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THAT YOU ARE SIMPLY TOO STUPID TO >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UNDERSTAND THIS IS NO ACTUAL >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> REBUTTAL AT ALL: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    The partial correct x86 emulation of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input to H(P,P) conclusively >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proves that the complete and correct >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> x86 emulation would never stop >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running.

    You SAY that, but you don't answer the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual questions about HOW. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    THAT YOU ARE SIMPLY TOO STUPID TO >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UNDERSTAND THIS IS NO EVIDENCE >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WHAT-SO-EVER THAT I DID NOT COMPLETELY >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PROVE THAT THE CORRECT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PARTIAL EMULATION OF THE INPUT TO >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) CONCLUSIVELY PROVES THAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THE CORRECT AND COMPLETE X86 EMULATION >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> OF THE INPUT TO H(P,P) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WOULD NEVER STOP RUNNING. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    It is completely obvious that when >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) correctly emulates its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input that it must emulate the first >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> seven instructions of P. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the seventh instruction of P >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeats this process we know >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> with complete certainty that the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete emulation of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P by H would never reach its final >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> “ret” instruction, thus never >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts.

    If P should have halted (i.e. no >>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite loop) then your simulation >>>>>>>>>>>>>>>>>>>>>>>>>>>>> detector, S (not H), gets the answer >>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong. You S is NOT a halting >>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider.

    /Flibble

    THAT YOU ARE SIMPLY TOO STUPID TO >>>>>>>>>>>>>>>>>>>>>>>>>>>> UNDERSTAND THIS IS NO ACTUAL >>>>>>>>>>>>>>>>>>>>>>>>>>>> REBUTTAL AT ALL.

    _P()
    [00001352](01)  55              push ebp
    [00001353](02)  8bec            mov >>>>>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp [00001355](03)  8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08] [00001358](01)  50 >>>>>>>>>>>>>>>>>>>>>>>>>>>> push eax      // push P [00001359](03) >>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08] [0000135c](01) >>>>>>>>>>>>>>>>>>>>>>>>>>>> 51 push ecx      // push P >>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000135d](05)  e840feffff call 000011a2 >>>>>>>>>>>>>>>>>>>>>>>>>>>> // call H [00001362](03)  83c408 add >>>>>>>>>>>>>>>>>>>>>>>>>>>> esp,+08 [00001365](02)  85c0 test eax,eax >>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001367](02)  7402            jz >>>>>>>>>>>>>>>>>>>>>>>>>>>> 0000136b [00001369](02)  ebfe >>>>>>>>>>>>>>>>>>>>>>>>>>>> jmp 00001369 [0000136b](01)  5d >>>>>>>>>>>>>>>>>>>>>>>>>>>> pop ebp [0000136c](01)  c3 >>>>>>>>>>>>>>>>>>>>>>>>>>>> ret Size in bytes:(0027) [0000136c] >>>>>>>>>>>>>>>>>>>>>>>>>>>>
    It is completely obvious that when H(P,P) >>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly emulates its >>>>>>>>>>>>>>>>>>>>>>>>>>>> input that it must emulate the first >>>>>>>>>>>>>>>>>>>>>>>>>>>> seven instructions of P. Because >>>>>>>>>>>>>>>>>>>>>>>>>>>> the seventh instruction of P repeats this >>>>>>>>>>>>>>>>>>>>>>>>>>>> process we know with >>>>>>>>>>>>>>>>>>>>>>>>>>>> complete certainty that the correct and >>>>>>>>>>>>>>>>>>>>>>>>>>>> complete emulation of P by H >>>>>>>>>>>>>>>>>>>>>>>>>>>> would never reach its final “ret” >>>>>>>>>>>>>>>>>>>>>>>>>>>> instruction, thus never halts. >>>>>>>>>>>>>>>>>>>>>>>>>>>
    We are going around and around and around >>>>>>>>>>>>>>>>>>>>>>>>>>> in circles. I will try again: >>>>>>>>>>>>>>>>>>>>>>>>>>>
    If you replace the opcodes "EB FE" at >>>>>>>>>>>>>>>>>>>>>>>>>>> 00001369 with the opcodes "90 90" >>>>>>>>>>>>>>>>>>>>>>>>>>> then your H gets the answer wrong: P >>>>>>>>>>>>>>>>>>>>>>>>>>> should have halted.

    /Flibble


    As I already said before this is merely >>>>>>>>>>>>>>>>>>>>>>>>>> your cluelessness that when H(P,P) is >>>>>>>>>>>>>>>>>>>>>>>>>> invoked the correct x86 emulation of the >>>>>>>>>>>>>>>>>>>>>>>>>> input to H(P,P) makes and code after >>>>>>>>>>>>>>>>>>>>>>>>>> [0000135d] unreachable.

    Wrong, because when that H return the value >>>>>>>>>>>>>>>>>>>>>>>>> 0, it will get there.
    Like I said people that are dumber than a box >>>>>>>>>>>>>>>>>>>>>>>> of rocks won't be able to correctly >>>>>>>>>>>>>>>>>>>>>>>> understand this.

    When H(P,P) is invoked the correctly emulated >>>>>>>>>>>>>>>>>>>>>>>> input to H(P,P) cannot possibly reach any >>>>>>>>>>>>>>>>>>>>>>>> instruction beyond [0000135d]. >>>>>>>>>>>>>>>>>>>>>>>
    So, you are defining that you H(P,P) never >>>>>>>>>>>>>>>>>>>>>>> returns because it is caught in the infinite >>>>>>>>>>>>>>>>>>>>>>> rcursion.

    Thats fine, just says it can't be the >>>>>>>>>>>>>>>>>>>>>>> correctly answering decider you claim it to >>>>>>>>>>>>>>>>>>>>>>> be.

    I have corrected you on this too many times. >>>>>>>>>>>>>>>>>>>>>>

    How. You need to define what H(P,P) actually >>>>>>>>>>>>>>>>>>>>> does.

    I have explained that too many times. >>>>>>>>>>>>>>>>>>>>
    To understand that H(P,P)==0 is correct we only >>>>>>>>>>>>>>>>>>>> need to know that H performs a correct x86 >>>>>>>>>>>>>>>>>>>> emulation of its input and then examine the >>>>>>>>>>>>>>>>>>>> execution trace.

    And a CORRECT emulation of the code will Halt if >>>>>>>>>>>>>>>>>>> H(P,P) returns 0, which it can only do if it does >>>>>>>>>>>>>>>>>>> not actually do a correct emulation

    The correctly emulated input to H(P,P) never gets >>>>>>>>>>>>>>>>>> past its machine address [0000135d].



    Only if H actually doesn't return 0. Yes, H can't >>>>>>>>>>>>>>>>> correctly return 0 if it correctly emulates its >>>>>>>>>>>>>>>>> input, but you can't drop that requirement. >>>>>>>>>>>>>>>>
    void P(u32 x)
    {
       if (H(x, x))
         HERE: goto HERE;
       return;
    }

    int main()
    {
       Output("Input_Halts = ", H((u32)P, >>>>>>>>>>>>>>>> (u32)P)); }

    When H returns 0 it does not returns 0 to P it >>>>>>>>>>>>>>>> returns 0 to main().

    But it also return 0 to the computation P(P), maybe >>>>>>>>>>>>>>> not the copy that it is simulating, since it aborts >>>>>>>>>>>>>>> that before it get to it,

    Finally you are not stupid or deceptive.

    If H never returns a value to P then H is not a halting >>>>>>>>>>>>> decider; if H returns a value of 0 to main() when P >>>>>>>>>>>>> halts then H is not a halting decider.

    H is not a halting decider; H is a simulation detector, >>>>>>>>>>>>> S.

    /Flibble


    In other words you are saying the infintely nested
    emulation only excutes for a few steps and then it stops >>>>>>>>>>>> on its own.

    I am saying that your H is not a halting decider; I am >>>>>>>>>>> saying that your H is just a simulation detector, S.

    /Flibble


    You are saying that you simply "don't believe in"
    simulating halt deciders.

    You haven't got a simulating halt decider, what you have got >>>>>>>>> is a simulation detector.

    /Flibble


    It is an easily verified fact that H does correctly decide
    the halt status of its input.

    void Infinite_Loop()
    {
    HERE: goto HERE;
    }

    int main()
    {
    Output("Input_Halts = ", H0(Infinite_Loop));
    }

    _Infinite_Loop()
    [00001342](01) 55 push ebp
    [00001343](02) 8bec mov ebp,esp
    [00001345](02) ebfe jmp 00001345
    [00001347](01) 5d pop ebp
    [00001348](01) c3 ret
    Size in bytes:(0007) [00001348]

    _main()
    [00001372](01) 55 push ebp
    [00001373](02) 8bec mov ebp,esp
    [00001375](05) 6842130000 push 00001342
    [0000137a](05) e833fdffff call 000010b2
    [0000137f](03) 83c404 add esp,+04
    [00001382](01) 50 push eax
    [00001383](05) 6823040000 push 00000423
    [00001388](05) e8e5f0ffff call 00000472
    [0000138d](03) 83c408 add esp,+08
    [00001390](02) 33c0 xor eax,eax
    [00001392](01) 5d pop ebp
    [00001393](01) c3 ret
    Size in bytes:(0034) [00001393]

    machine stack stack machine assembly
    address address data code language
    ======== ======== ======== ========= ============= >>>>>>>> [00001372][0010228f][00000000] 55 push ebp
    [00001373][0010228f][00000000] 8bec mov ebp,esp
    [00001375][0010228b][00001342] 6842130000 push 00001342 //
    push _Infinite_Loop
    [0000137a][00102287][0000137f] e833fdffff call 000010b2 //
    call H0

    Begin Local Halt Decider Simulation Execution Trace Stored >>>>>>>> at:212343 [00001342][00212333][00212337] 55 push ebp >>>>>>>> [00001343][00212333][00212337] 8bec mov ebp,esp
    [00001345][00212333][00212337] ebfe jmp 00001345
    [00001345][00212333][00212337] ebfe jmp 00001345
    Local Halt Decider: Infinite Loop Detected Simulation Stopped >>>>>>>>
    [0000137f][0010228f][00000000] 83c404 add esp,+04
    [00001382][0010228b][00000000] 50 push eax
    [00001383][00102287][00000423] 6823040000 push 00000423
    [00001388][00102287][00000423] e8e5f0ffff call 00000472
    Input_Halts = 0
    [0000138d][0010228f][00000000] 83c408 add esp,+08
    [00001390][0010228f][00000000] 33c0 xor eax,eax
    [00001392][00102293][00100000] 5d pop ebp
    [00001393][00102297][00000004] c3 ret
    Number of Instructions Executed(680)

    int Sum(int X, int Y)
    {
    return X + Y;
    }

    int main()
    {
    Output("Input_Halts = ", H2(Sum, 3, 4));
    }

    _Sum()
    [000012b6](01) 55 push ebp
    [000012b7](02) 8bec mov ebp,esp
    [000012b9](03) 8b4508 mov eax,[ebp+08]
    [000012bc](03) 03450c add eax,[ebp+0c]
    [000012bf](01) 5d pop ebp
    [000012c0](01) c3 ret
    Size in bytes:(0011) [000012c0]

    _main()
    [00001316](01) 55 push ebp
    [00001317](02) 8bec mov ebp,esp
    [00001319](02) 6a04 push +04
    [0000131b](02) 6a03 push +03
    [0000131d](05) 68b6120000 push 000012b6
    [00001322](05) e85ffaffff call 00000d86
    [00001327](03) 83c40c add esp,+0c
    [0000132a](01) 50 push eax
    [0000132b](05) 6807040000 push 00000407
    [00001330](05) e821f1ffff call 00000456
    [00001335](03) 83c408 add esp,+08
    [00001338](02) 33c0 xor eax,eax
    [0000133a](01) 5d pop ebp
    [0000133b](01) c3 ret
    Size in bytes:(0038) [0000133b]

    machine stack stack machine assembly
    address address data code language
    ======== ======== ======== ========= ============= >>>>>>>> ...[00001316][001021d7][00000000] 55 push ebp
    ...[00001317][001021d7][00000000] 8bec mov ebp,esp >>>>>>>> ...[00001319][001021d3][00000004] 6a04 push +04
    ...[0000131b][001021cf][00000003] 6a03 push +03
    ...[0000131d][001021cb][000012b6] 68b6120000 push
    000012b6 ...[00001322][001021c7][00001327] e85ffaffff
    call 00000d86

    Begin Local Halt Decider Simulation Execution Trace Stored >>>>>>>> at:21228b ...[000012b6][00212273][00212277] 55
    push ebp ...[000012b7][00212273][00212277] 8bec
    mov ebp,esp ...[000012b9][00212273][00212277] 8b4508
    mov eax,[ebp+08] ...[000012bc][00212273][00212277] 03450c
    add eax,[ebp+0c] ...[000012bf][00212277][00000e54] 5d
    pop ebp ...[000012c0][0021227b][00000003] c3
    ret ...[00001327][001021d7][00000000] 83c40c add
    esp,+0c ...[0000132a][001021d3][00000001] 50
    push eax ...[0000132b][001021cf][00000407] 6807040000
    push 00000407 ---[00001330][001021cf][00000407] e821f1ffff
    call 00000456 Input_Halts = 1
    ...[00001335][001021d7][00000000] 83c408 add esp,+08 >>>>>>>> ...[00001338][001021d7][00000000] 33c0 xor eax,eax >>>>>>>> ...[0000133a][001021db][00100000] 5d pop ebp
    ...[0000133b][001021df][00000004] c3 ret
    Number of Instructions Executed(660)

    All you are showing here is that your H can decide the halt
    status of two trivial cases however you have not shown that H
    can decide the halt status of non-trivial cases.


    You said:
    "You haven't got a simulating halt decider"
    Apologize and we can move on.

    I posted four paragraphs but you ignored three of them. Lets try
    again.

    IF YOU DON'T APOLOGIZE THEN WE CANNOT MOVE ON !!!

    It seems I need to try again. Perhaps it will help if I combine
    the four paragraphs into a single paragraph:

    All you are showing here is that your H can decide the halt status
    of two trivial cases however you have not shown that H can decide
    the halt status of non-trivial cases.

    H is a halt decider for a subset of its inputs.
    H is a halt decider for P.
    When H is a halt decider for P all of the conventional halting
    problem proofs have been refuted.

    For H to be a halt decider it needs to be a halt decider for all
    inputs not a subset.


    Publish the source code of your halt
    decider so we can see what classes of programs your H can decide.
    I am interested in deciding the halt status of programs containing
    non-trivial branching logic predicated on arbitrary program
    input.

    These are out-of-scope.

    You may assert this but that doesn't make your assertion true. If
    they are out-of-scope then your H is out of scope of the Halting
    Problem.

    Crucially if your H cannot return an answer for an arbitrary
    non-halting program in finite time then it isn't a halt decider.

    One can either say that H is a halt decider for a subset of its
    inputs or that H is a halt determiner. As long as H(P,P) correctly
    decides its input all of the conventional HP proofs have been
    refuted.

    If we are to make progress you need to publish the code of your
    infinite loop detector.

    If you can't understand 14 lines of code then this conclusively
    proves that you won't understand hundreds of pages of code.

    Because people here are only interested in rebuttal and don't give a
    rat's ass about an honest dialogue I make the price of a continued
    dialogue key points of mutual agreement.

    If you don't understand that H(P,P)==0 is correct then providing the
    source code will only provide the means for denigration based on lack
    of comprehension. I absolutely will not tolerate that.

    If we are to make progress you need to publish the source code of how
    your infinite loop detector works as your disassembly traces DO NOT
    provide that information.

    /Flibble

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Fri Jun 10 10:19:54 2022
    XPost: comp.theory, sci.logic, sci.math

    On 6/10/22 9:59 AM, olcott wrote:
    On 6/10/2022 8:51 AM, Mr Flibble wrote:
    On Fri, 10 Jun 2022 08:43:48 -0500
    olcott <NoOne@NoWhere.com> wrote:

    On 6/10/2022 8:35 AM, Mr Flibble wrote:
    On Fri, 10 Jun 2022 08:33:27 -0500
    olcott <NoOne@NoWhere.com> wrote:
    On 6/10/2022 8:29 AM, Mr Flibble wrote:
    On Fri, 10 Jun 2022 08:27:28 -0500
    olcott <NoOne@NoWhere.com> wrote:
    On 6/10/2022 8:23 AM, Mr Flibble wrote:
    On Fri, 10 Jun 2022 08:05:57 -0500
    olcott <NoOne@NoWhere.com> wrote:
    On 6/10/2022 6:11 AM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:35:05 -0500
    olcott <NoOne@NoWhere.com> wrote:
    On 6/9/2022 5:27 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:18:38 -0500
    olcott <NoOne@NoWhere.com> wrote:
    On 6/9/2022 5:15 PM, Mr Flibble wrote:
    On Thu, 9 Jun 2022 17:09:08 -0500
    olcott <NoOne@NoWhere.com> wrote:
    On 6/9/2022 4:54 PM, Richard Damon wrote:
    On 6/9/22 5:29 PM, olcott wrote:
    On 6/9/2022 4:13 PM, Richard Damon wrote:

    On 6/9/22 5:00 PM, olcott wrote:
    On 6/9/2022 3:25 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 6/9/22 4:13 PM, olcott wrote:
    On 6/9/2022 2:57 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 6/9/22 3:52 PM, olcott wrote:
    On 6/9/2022 2:38 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>
    On 6/9/22 3:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 1:12 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 1:55 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 12:46 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 12:39:32 -0500 >>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>