All of my reviewers deny the verified facts by using the straw-man deception

[olcott]

*Halting is defined as reaching a final state and terminating normally*

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

Anyone with sufficient software engineering skill knows that
*D simulated by H cannot possibly correctly reach its ret instruction*
Everyone else lacks sufficient software engineering skill or lies

_D()
[00001d12] 55 push ebp
[00001d13] 8bec mov ebp,esp
[00001d15] 51 push ecx
[00001d16] 8b4508 mov eax,[ebp+08] // move 1st argument to eax
[00001d19] 50 push eax // push D
[00001d1a] 8b4d08 mov ecx,[ebp+08] // move 1st argument to ecx
[00001d1d] 51 push ecx // push D
[00001d1e] e83ff8ffff call 00001562 // call H same as H(D,D)
[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

H simulates machine instructions of D from [00001d12] to [00001d1e]
then could simulate D again endlessly (until D runs out of stack space)
or H could abort its entire simulation chain at some point. In both of
these mutually exclusive cases D simulated by H never reaches its own
ret instruction.

*straw-man*
An intentionally misrepresented proposition that is set up because it is
easier to defeat than an opponent's real argument.
https://www.lexico.com/en/definition/straw_man

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

[Richard Damon]

On 2/22/23 12:35 PM, olcott wrote:
> *Halting is defined as reaching a final state and terminating normally*

Right, of the actual execution of the machine

Remember: In computability theory, the halting problem is the problem of
determining, from a description of an arbitrary computer program and an
input, whether the program will finish running, or continue to run forever.

>
> int D(int (*x)())
> {
>   int Halt_Status = H(x, x);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return Halt_Status;
> }
>
> Anyone with sufficient software engineering skill knows that
> *D simulated by H cannot possibly correctly reach its ret instruction*
> Everyone else lacks sufficient software engineering skill or lies

Which isn't the criteria, so you are using a strawman.

>
> _D()
>  [00001d12] 55         push ebp
>  [00001d13] 8bec       mov ebp,esp
>  [00001d15] 51         push ecx
>  [00001d16] 8b4508     mov eax,[ebp+08] // move 1st argument to eax
>  [00001d19] 50         push eax         // push D
>  [00001d1a] 8b4d08     mov ecx,[ebp+08] // move 1st argument to ecx
>  [00001d1d] 51         push ecx         // push D
>  [00001d1e] e83ff8ffff call 00001562    // call H same as H(D,D)
>  [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
>
> H simulates machine instructions of D from [00001d12] to [00001d1e]
> then could simulate D again endlessly (until D runs out of stack space)
> or H could abort its entire simulation chain at some point. In both of
> these mutually exclusive cases D simulated by H never reaches its own
> ret instruction.

maybe it COULD, but we know it DOES abort its simulation and return 0
and thus makes D(D) halting.

You don't seem to understand that computate programs do what they are
programmed to do.

>
> *straw-man*
> An intentionally misrepresented proposition that is set up because it is
> easier to defeat than an opponent's real argument.
> https://www.lexico.com/en/definition/straw_man
>

Exactly what you "alternate" criteria is.

So PROVEN.