*The behavior of D(D) is changed when the simulated D is specified*
*to have a pathological relationship with its own simulator*

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.

_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

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

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
>

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
and
H1 DOES NOT abort and returns 1 // H1(D,D) sees that need not abort

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

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

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

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

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*

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

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

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

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.

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

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.