1. Forum
  2. Usenet
  3. COMP.THEORY

  • Re: The behavior of D(D) varies between its correct simulation by H1(D,

    From Richard Damon@21:1/5 to olcott on Fri Mar 22 22:17:08 2024
    XPost: sci.logic

    On 3/22/24 11:34 AM, olcott wrote:
    *The behavior of D(D) is changed when the simulated D is specified*
    *to have a pathological relationship with its own simulator*

    Nope. H just makes a INVALID deduction that the call to H will not
    return when properly simulated (which it can not do).


    D(D) simulated by H1 calls H(D,D) from its own machine address 00001d1e returns to its caller at machine address 00001d54.

    *Contrasted with*

    D(D) simulated by H calls H(D,D) from its own machine address 00001d1e
    and cannot possibly return to its caller because it would remain stuck
    in recursive simulation until aborted.

    Nope, since H DOES abort and return 0, the CORRECT SIMULATION of this
    input will do this too (just as H1 did).

    The fact that a DIFFERENT machine, that isn't what H actually is, would
    get stuck in an infinite loop is irrelevant, as H isnt that other
    machine, and looking at the other machine is just invalid logic.



    _D()
    [00001d12] 55         push ebp
    [00001d13] 8bec       mov ebp,esp
    [00001d15] 51         push ecx
    [00001d16] 8b4508     mov eax,[ebp+08]
    [00001d19] 50         push eax
    [00001d1a] 8b4d08     mov ecx,[ebp+08]
    [00001d1d] 51         push ecx
    [00001d1e] e81ff8ffff call 00001542
    [00001d23] 83c408     add esp,+08
    [00001d26] 8945fc     mov [ebp-04],eax
    [00001d29] 837dfc00   cmp dword [ebp-04],+00
    [00001d2d] 7402       jz 00001d31
    [00001d2f] ebfe       jmp 00001d2f
    [00001d31] 8b45fc     mov eax,[ebp-04]
    [00001d34] 8be5       mov esp,ebp
    [00001d36] 5d         pop ebp
    [00001d37] c3         ret
    Size in bytes:(0038) [00001d37]

    _main()
    [00001d42] 55         push ebp
    [00001d43] 8bec       mov ebp,esp
    [00001d45] 68121d0000 push 00001d12 ; push address of D
    [00001d4a] 68121d0000 push 00001d12 ; push address of D
    [00001d4f] e8eef6ffff call 00001442 ; call H1(D,D)
    [00001d54] 83c408     add esp,+08
    [00001d57] 50         push eax
    [00001d58] 6863070000 push 00000763
    [00001d5d] e820eaffff call 00000782
    [00001d62] 83c408     add esp,+08
    [00001d65] 33c0       xor eax,eax
    [00001d67] 5d         pop ebp
    [00001d68] c3         ret
    Size in bytes:(0039) [00001d68]

    int D(int (*x)())
    {
      int Halt_Status = H(x, x);
      if (Halt_Status)
        HERE: goto HERE;
      return Halt_Status;
    }

    int main()
    { // The call from D simulated by H1 to H(D,D) return 1.
      // The call from D simulated by H to H(D,D) cannot possibly return.
      Output("Input_Halts = ", H1(D,D));
    }

     machine   stack     stack     machine    assembly
     address   address   data      code       language
     ========  ========  ========  =========  ============= [00001d42][00102fe9][00000000] 55         push ebp      ; begin main()
    [00001d43][00102fe9][00000000] 8bec       mov  ebp,esp [00001d45][00102fe5][00001d12] 68121d0000 push 00001d12 ; push D [00001d4a][00102fe1][00001d12] 68121d0000 push 00001d12 ; push D [00001d4f][00102fdd][00001d54] e8eef6ffff call 00001442 ; call H1(D,D)

    H1: Begin Simulation   Execution Trace Stored at:113095
    Address_of_H1:1442
    [00001d12][00113081][00113085] 55         push ebp      ; begin D
    [00001d13][00113081][00113085] 8bec       mov  ebp,esp [00001d15][0011307d][00103051] 51         push ecx [00001d16][0011307d][00103051] 8b4508     mov  eax,[ebp+08] [00001d19][00113079][00001d12] 50         push eax      ; push D [00001d1a][00113079][00001d12] 8b4d08     mov  ecx,[ebp+08] [00001d1d][00113075][00001d12] 51         push ecx      ; push D [00001d1e][00113071][00001d23] e81ff8ffff call 00001542 ; call H(D,D)

    H: Begin Simulation   Execution Trace Stored at:15dabd
    Address_of_H:1542
    [00001d12][0015daa9][0015daad] 55         push ebp      ; begin D
    [00001d13][0015daa9][0015daad] 8bec       mov  ebp,esp [00001d15][0015daa5][0014da79] 51         push ecx [00001d16][0015daa5][0014da79] 8b4508     mov  eax,[ebp+08] [00001d19][0015daa1][00001d12] 50         push eax      ; push D [00001d1a][0015daa1][00001d12] 8b4d08     mov  ecx,[ebp+08] [00001d1d][0015da9d][00001d12] 51         push ecx      ; push D [00001d1e][0015da99][00001d23] e81ff8ffff call 00001542 ; call H(D,D)
    H: Recursive Simulation Detected Simulation Stopped (return 0 to caller)

    [00001d23][0011307d][00103051] 83c408     add esp,+08   ; returned to D [00001d26][0011307d][00000000] 8945fc     mov [ebp-04],eax [00001d29][0011307d][00000000] 837dfc00   cmp dword [ebp-04],+00 [00001d2d][0011307d][00000000] 7402       jz 00001d31 [00001d31][0011307d][00000000] 8b45fc     mov eax,[ebp-04] [00001d34][00113081][00113085] 8be5       mov esp,ebp [00001d36][00113085][00001541] 5d         pop ebp [00001d37][00113089][00001d12] c3         ret           ; exit D
    H1: End Simulation   Input Terminated Normally (return 1 to caller)

    [00001d54][00102fe9][00000000] 83c408     add  esp,+08 [00001d57][00102fe5][00000001] 50         push eax     ; H1 return value
    [00001d58][00102fe1][00000763] 6863070000 push 00000763 ; string address [00001d5d][00102fe1][00000763] e820eaffff call 00000782 ; call Output Input_Halts = 1
    [00001d62][00102fe9][00000000] 83c408     add esp,+08 [00001d65][00102fe9][00000000] 33c0       xor eax,eax [00001d67][00102fed][00000018] 5d         pop ebp [00001d68][00102ff1][00000000] c3         ret           ; exit main()
    Number of Instructions Executed(470247) == 7019 Pages


    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Fri Mar 22 22:50:07 2024
    XPost: sci.logic

    On 3/22/24 10:33 PM, olcott wrote:
    On 3/22/2024 9:17 PM, Richard Damon wrote:
    On 3/22/24 11:34 AM, olcott wrote:
    *The behavior of D(D) is changed when the simulated D is specified*
    *to have a pathological relationship with its own simulator*

    Nope. H just makes a INVALID deduction that the call to H will not
    return when properly simulated (which it can not do).


    D(D) simulated by H1 calls H(D,D) from its own machine address
    00001d1e returns to its caller at machine address 00001d54.

    *Contrasted with*

    D(D) simulated by H calls H(D,D) from its own machine address
    00001d1e and cannot possibly return to its caller because it would
    remain stuck in recursive simulation until aborted.

    Nope, since H DOES abort and return 0, the CORRECT SIMULATION of this
    input will do this too (just as H1 did).


    H DOES abort and returns 0       // H(D,D) sees that it must abort


    IT THINKS it must abort, but by the DEFINITION that YOU AGREED to, it
    turns out it doesn't because the D that it simulates is calling an H
    that will return 0 and thus cause D to halt.

    THus THIS instance of H doesn't NEED to abort, but does as that is its programming

    and
    H1 DOES NOT abort and returns 1  // H1(D,D) sees that need not abort

    And provides the correct simulation that shows that H didn't NEED to abort.


    The x86 emulator has decades of development effort and every
    step shown below proves to be correct simulation.

    Except for the call to H, that was never ACTUALLY simulated.


    The fact that a DIFFERENT machine, that isn't what H actually is,
    would get stuck in an infinite loop is irrelevant, as H isnt that
    other machine, and looking at the other machine is just invalid logic.



    _D()
    [00001d12] 55         push ebp
    [00001d13] 8bec       mov ebp,esp
    [00001d15] 51         push ecx
    [00001d16] 8b4508     mov eax,[ebp+08]
    [00001d19] 50         push eax
    [00001d1a] 8b4d08     mov ecx,[ebp+08]
    [00001d1d] 51         push ecx
    [00001d1e] e81ff8ffff call 00001542
    [00001d23] 83c408     add esp,+08
    [00001d26] 8945fc     mov [ebp-04],eax
    [00001d29] 837dfc00   cmp dword [ebp-04],+00
    [00001d2d] 7402       jz 00001d31
    [00001d2f] ebfe       jmp 00001d2f
    [00001d31] 8b45fc     mov eax,[ebp-04]
    [00001d34] 8be5       mov esp,ebp
    [00001d36] 5d         pop ebp
    [00001d37] c3         ret
    Size in bytes:(0038) [00001d37]

    _main()
    [00001d42] 55         push ebp
    [00001d43] 8bec       mov ebp,esp
    [00001d45] 68121d0000 push 00001d12 ; push address of D
    [00001d4a] 68121d0000 push 00001d12 ; push address of D
    [00001d4f] e8eef6ffff call 00001442 ; call H1(D,D)
    [00001d54] 83c408     add esp,+08
    [00001d57] 50         push eax
    [00001d58] 6863070000 push 00000763
    [00001d5d] e820eaffff call 00000782
    [00001d62] 83c408     add esp,+08
    [00001d65] 33c0       xor eax,eax
    [00001d67] 5d         pop ebp
    [00001d68] c3         ret
    Size in bytes:(0039) [00001d68]

    int D(int (*x)())
    {
       int Halt_Status = H(x, x);
       if (Halt_Status)
         HERE: goto HERE;
       return Halt_Status;
    }

    int main()
    { // The call from D simulated by H1 to H(D,D) return 1.
       // The call from D simulated by H to H(D,D) cannot possibly return. >>>    Output("Input_Halts = ", H1(D,D));
    }

      machine   stack     stack     machine    assembly
      address   address   data      code       language
      ========  ========  ========  =========  =============
    [00001d42][00102fe9][00000000] 55         push ebp      ; begin main()
    [00001d43][00102fe9][00000000] 8bec       mov  ebp,esp
    [00001d45][00102fe5][00001d12] 68121d0000 push 00001d12 ; push D
    [00001d4a][00102fe1][00001d12] 68121d0000 push 00001d12 ; push D
    [00001d4f][00102fdd][00001d54] e8eef6ffff call 00001442 ; call H1(D,D)

    H1: Begin Simulation   Execution Trace Stored at:113095
    Address_of_H1:1442
    [00001d12][00113081][00113085] 55         push ebp      ; begin D
    [00001d13][00113081][00113085] 8bec       mov  ebp,esp
    [00001d15][0011307d][00103051] 51         push ecx
    [00001d16][0011307d][00103051] 8b4508     mov  eax,[ebp+08]
    [00001d19][00113079][00001d12] 50         push eax      ; push D
    [00001d1a][00113079][00001d12] 8b4d08     mov  ecx,[ebp+08]
    [00001d1d][00113075][00001d12] 51         push ecx      ; push D
    [00001d1e][00113071][00001d23] e81ff8ffff call 00001542 ; call H(D,D)

    H: Begin Simulation   Execution Trace Stored at:15dabd
    Address_of_H:1542
    [00001d12][0015daa9][0015daad] 55         push ebp      ; begin D
    [00001d13][0015daa9][0015daad] 8bec       mov  ebp,esp
    [00001d15][0015daa5][0014da79] 51         push ecx
    [00001d16][0015daa5][0014da79] 8b4508     mov  eax,[ebp+08]
    [00001d19][0015daa1][00001d12] 50         push eax      ; push D
    [00001d1a][0015daa1][00001d12] 8b4d08     mov  ecx,[ebp+08]
    [00001d1d][0015da9d][00001d12] 51         push ecx      ; push D
    [00001d1e][0015da99][00001d23] e81ff8ffff call 00001542 ; call H(D,D)
    H: Recursive Simulation Detected Simulation Stopped (return 0 to caller)

    Which is proved incorrect by H1.

    H is seeing the start of just a single level of simulation that will
    return a "I think non-halting" answer (that is incorrect).


    [00001d23][0011307d][00103051] 83c408     add esp,+08   ; returned to D
    [00001d26][0011307d][00000000] 8945fc     mov [ebp-04],eax
    [00001d29][0011307d][00000000] 837dfc00   cmp dword [ebp-04],+00
    [00001d2d][0011307d][00000000] 7402       jz 00001d31
    [00001d31][0011307d][00000000] 8b45fc     mov eax,[ebp-04]
    [00001d34][00113081][00113085] 8be5       mov esp,ebp
    [00001d36][00113085][00001541] 5d         pop ebp
    [00001d37][00113089][00001d12] c3         ret           ; exit D
    H1: End Simulation   Input Terminated Normally (return 1 to caller)

    [00001d54][00102fe9][00000000] 83c408     add  esp,+08
    [00001d57][00102fe5][00000001] 50         push eax     ; H1 return value
    [00001d58][00102fe1][00000763] 6863070000 push 00000763 ; string address >>> [00001d5d][00102fe1][00000763] e820eaffff call 00000782 ; call Output
    Input_Halts = 1
    [00001d62][00102fe9][00000000] 83c408     add esp,+08
    [00001d65][00102fe9][00000000] 33c0       xor eax,eax
    [00001d67][00102fed][00000018] 5d         pop ebp
    [00001d68][00102ff1][00000000] c3         ret           ; exit main()
    Number of Instructions Executed(470247) == 7019 Pages




    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Sat Mar 23 10:14:55 2024
    XPost: sci.logic

    On 3/22/24 10:55 PM, olcott wrote:
    On 3/22/2024 9:50 PM, Richard Damon wrote:
    On 3/22/24 10:33 PM, olcott wrote:
    On 3/22/2024 9:17 PM, Richard Damon wrote:
    On 3/22/24 11:34 AM, olcott wrote:
    *The behavior of D(D) is changed when the simulated D is specified*
    *to have a pathological relationship with its own simulator*

    Nope. H just makes a INVALID deduction that the call to H will not
    return when properly simulated (which it can not do).


    D(D) simulated by H1 calls H(D,D) from its own machine address
    00001d1e returns to its caller at machine address 00001d54.

    *Contrasted with*

    D(D) simulated by H calls H(D,D) from its own machine address
    00001d1e and cannot possibly return to its caller because it would
    remain stuck in recursive simulation until aborted.

    Nope, since H DOES abort and return 0, the CORRECT SIMULATION of
    this input will do this too (just as H1 did).


    H DOES abort and returns 0       // H(D,D) sees that it must abort


    IT THINKS it must abort, but by the DEFINITION that YOU AGREED to, it
    turns out it doesn't because the D that it simulates is calling an H
    that will return 0 and thus cause D to halt.


    *In other words you have no shame in contradicting yourself*
    *In other words you have no shame in contradicting yourself*
    *In other words you have no shame in contradicting yourself*

    What CONTRADICTION?


    On 3/20/2024 6:02 PM, Richard Damon wrote:
    On 3/20/24 6:01 PM, olcott wrote:
    Every H(D,D) that doesn't abort its simulated input
    never stops running.

    Yep, shows that H's that don't abort the D built on
    them won't be deciders...

    Yep, OTHER H's, with different code don't answer.

    You are just proving you are just stupid and don't understand logic.

    Why does the fact that Cats are not 10 story office buildings mean they
    do not need to eat?


    THus THIS instance of H doesn't NEED to abort, but does as that is its
    programming

    and
    H1 DOES NOT abort and returns 1  // H1(D,D) sees that need not abort

    And provides the correct simulation that shows that H didn't NEED to
    abort.


    The x86 emulator has decades of development effort and every
    step shown below proves to be correct simulation.

    Except for the call to H, that was never ACTUALLY simulated.


    The fact that a DIFFERENT machine, that isn't what H actually is,
    would get stuck in an infinite loop is irrelevant, as H isnt that
    other machine, and looking at the other machine is just invalid logic. >>>>


    _D()
    [00001d12] 55         push ebp
    [00001d13] 8bec       mov ebp,esp
    [00001d15] 51         push ecx
    [00001d16] 8b4508     mov eax,[ebp+08]
    [00001d19] 50         push eax
    [00001d1a] 8b4d08     mov ecx,[ebp+08]
    [00001d1d] 51         push ecx
    [00001d1e] e81ff8ffff call 00001542
    [00001d23] 83c408     add esp,+08
    [00001d26] 8945fc     mov [ebp-04],eax
    [00001d29] 837dfc00   cmp dword [ebp-04],+00
    [00001d2d] 7402       jz 00001d31
    [00001d2f] ebfe       jmp 00001d2f
    [00001d31] 8b45fc     mov eax,[ebp-04]
    [00001d34] 8be5       mov esp,ebp
    [00001d36] 5d         pop ebp
    [00001d37] c3         ret
    Size in bytes:(0038) [00001d37]

    _main()
    [00001d42] 55         push ebp
    [00001d43] 8bec       mov ebp,esp
    [00001d45] 68121d0000 push 00001d12 ; push address of D
    [00001d4a] 68121d0000 push 00001d12 ; push address of D
    [00001d4f] e8eef6ffff call 00001442 ; call H1(D,D)
    [00001d54] 83c408     add esp,+08
    [00001d57] 50         push eax
    [00001d58] 6863070000 push 00000763
    [00001d5d] e820eaffff call 00000782
    [00001d62] 83c408     add esp,+08
    [00001d65] 33c0       xor eax,eax
    [00001d67] 5d         pop ebp
    [00001d68] c3         ret
    Size in bytes:(0039) [00001d68]

    int D(int (*x)())
    {
       int Halt_Status = H(x, x);
       if (Halt_Status)
         HERE: goto HERE;
       return Halt_Status;
    }

    int main()
    { // The call from D simulated by H1 to H(D,D) return 1.
       // The call from D simulated by H to H(D,D) cannot possibly return. >>>>>    Output("Input_Halts = ", H1(D,D));
    }

      machine   stack     stack     machine    assembly
      address   address   data      code       language >>>>>   ========  ========  ========  =========  =============
    [00001d42][00102fe9][00000000] 55         push ebp      ; begin main()
    [00001d43][00102fe9][00000000] 8bec       mov  ebp,esp
    [00001d45][00102fe5][00001d12] 68121d0000 push 00001d12 ; push D
    [00001d4a][00102fe1][00001d12] 68121d0000 push 00001d12 ; push D
    [00001d4f][00102fdd][00001d54] e8eef6ffff call 00001442 ; call H1(D,D) >>>>>
    H1: Begin Simulation   Execution Trace Stored at:113095
    Address_of_H1:1442
    [00001d12][00113081][00113085] 55         push ebp      ; begin D
    [00001d13][00113081][00113085] 8bec       mov  ebp,esp
    [00001d15][0011307d][00103051] 51         push ecx
    [00001d16][0011307d][00103051] 8b4508     mov  eax,[ebp+08]
    [00001d19][00113079][00001d12] 50         push eax      ; push D
    [00001d1a][00113079][00001d12] 8b4d08     mov  ecx,[ebp+08]
    [00001d1d][00113075][00001d12] 51         push ecx      ; push D
    [00001d1e][00113071][00001d23] e81ff8ffff call 00001542 ; call H(D,D) >>>>>
    H: Begin Simulation   Execution Trace Stored at:15dabd
    Address_of_H:1542
    [00001d12][0015daa9][0015daad] 55         push ebp      ; begin D
    [00001d13][0015daa9][0015daad] 8bec       mov  ebp,esp
    [00001d15][0015daa5][0014da79] 51         push ecx
    [00001d16][0015daa5][0014da79] 8b4508     mov  eax,[ebp+08]
    [00001d19][0015daa1][00001d12] 50         push eax      ; push D
    [00001d1a][0015daa1][00001d12] 8b4d08     mov  ecx,[ebp+08]
    [00001d1d][0015da9d][00001d12] 51         push ecx      ; push D
    [00001d1e][0015da99][00001d23] e81ff8ffff call 00001542 ; call H(D,D) >>>>> H: Recursive Simulation Detected Simulation Stopped (return 0 to
    caller)

    Which is proved incorrect by H1.

    H is seeing the start of just a single level of simulation that will
    return a "I think non-halting" answer (that is incorrect).


    [00001d23][0011307d][00103051] 83c408     add esp,+08   ; returned >>>>> to D
    [00001d26][0011307d][00000000] 8945fc     mov [ebp-04],eax
    [00001d29][0011307d][00000000] 837dfc00   cmp dword [ebp-04],+00
    [00001d2d][0011307d][00000000] 7402       jz 00001d31
    [00001d31][0011307d][00000000] 8b45fc     mov eax,[ebp-04]
    [00001d34][00113081][00113085] 8be5       mov esp,ebp
    [00001d36][00113085][00001541] 5d         pop ebp
    [00001d37][00113089][00001d12] c3         ret           ; exit D
    H1: End Simulation   Input Terminated Normally (return 1 to caller) >>>>>
    [00001d54][00102fe9][00000000] 83c408     add  esp,+08
    [00001d57][00102fe5][00000001] 50         push eax     ; H1 return
    value
    [00001d58][00102fe1][00000763] 6863070000 push 00000763 ; string
    address
    [00001d5d][00102fe1][00000763] e820eaffff call 00000782 ; call Output >>>>> Input_Halts = 1
    [00001d62][00102fe9][00000000] 83c408     add esp,+08
    [00001d65][00102fe9][00000000] 33c0       xor eax,eax
    [00001d67][00102fed][00000018] 5d         pop ebp
    [00001d68][00102ff1][00000000] c3         ret           ; exit main()
    Number of Instructions Executed(470247) == 7019 Pages






    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Sat Mar 23 13:08:12 2024
    XPost: sci.logic

    On 3/23/24 11:58 AM, olcott wrote:
    On 3/23/2024 9:14 AM, Richard Damon wrote:
    On 3/22/24 10:55 PM, olcott wrote:
    On 3/22/2024 9:50 PM, Richard Damon wrote:
    On 3/22/24 10:33 PM, olcott wrote:
    On 3/22/2024 9:17 PM, Richard Damon wrote:
    On 3/22/24 11:34 AM, olcott wrote:
    *The behavior of D(D) is changed when the simulated D is specified* >>>>>>> *to have a pathological relationship with its own simulator*

    Nope. H just makes a INVALID deduction that the call to H will not >>>>>> return when properly simulated (which it can not do).


    D(D) simulated by H1 calls H(D,D) from its own machine address
    00001d1e returns to its caller at machine address 00001d54.

    *Contrasted with*

    D(D) simulated by H calls H(D,D) from its own machine address
    00001d1e and cannot possibly return to its caller because it
    would remain stuck in recursive simulation until aborted.

    Nope, since H DOES abort and return 0, the CORRECT SIMULATION of
    this input will do this too (just as H1 did).


    H DOES abort and returns 0       // H(D,D) sees that it must abort >>>>

    IT THINKS it must abort, but by the DEFINITION that YOU AGREED to,
    it turns out it doesn't because the D that it simulates is calling
    an H that will return 0 and thus cause D to halt.


    *In other words you have no shame in contradicting yourself*
    *In other words you have no shame in contradicting yourself*
    *In other words you have no shame in contradicting yourself*

    What CONTRADICTION?


    On 3/20/2024 6:02 PM, Richard Damon wrote:
    On 3/20/24 6:01 PM, olcott wrote:
    Every H(D,D) that doesn't abort its simulated input
    never stops running.
    ;
    Yep, shows that H's that don't abort the D built on
    them won't be deciders...

    Yep, OTHER H's, with different code don't answer.


    Of all of the elements of the set of H(D,D) where H simulates its
    input there are matched pairs of otherwise identical elements that
    only differ by whether they abort their simulation or not.

    The half of these that don't abort are incorrect because all deciders
    must halt. This makes the other half correct about the abort/no abort decision.


    And the half that DO abort are incorrect because when they abort, then
    make D be a halting Computation that doesn't need to be aborted.

    You are just using unsound an invalid logic, as that seems to be all you
    know.

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