XPost: sci.logic, comp.theory, comp.software-eng

*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

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

XPost: sci.logic, comp.theory, comp.software-eng

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.

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