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

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
>

>

>

>