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

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

int main()
{
Output("Input_Halts = ", H(D,D));
Output("Input_Halts = ", D(D));
}

H(D,D) does correctly compute the mapping from its input to its reject
state on the basis that H correctly predicts that D correctly simulated
by H would never halt.

--
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: comp.theory, sci.logic, comp.software-eng

On 2/16/23 9:43 AM, olcott wrote:

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

int main()
{
  Output("Input_Halts = ", H(D,D));
  Output("Input_Halts = ", D(D));
}

H(D,D) does correctly compute the mapping from its input to its reject
state on the basis that H correctly predicts that D correctly simulated
by H would never halt.

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.

D(D) Halts

H(D,D) says Non-Halting and is claimed correct

Therefore H is NOT a Halting Decider, but just a POOP decider (what your
actual criteria is talking about).

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

On Thursday, February 16, 2023 at 5:50:59 PM UTC-6, Richard Damon wrote:

On 2/16/23 9:43 AM, olcott wrote:

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

int main()
{
Output("Input_Halts = ", H(D,D));
Output("Input_Halts = ", D(D));
}

H(D,D) does correctly compute the mapping from its input to its reject state on the basis that H correctly predicts that D correctly simulated
by H would never halt.

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.

D(D) Halts

H(D,D) says Non-Halting and is claimed correct

Therefore H is NOT a Halting Decider, but just a POOP decider (what your actual criteria is talking about).

"Mommy , when will this system halt?"

"Well, little Felicity , why don't you just take a practical approach , you just sit back and watch it and when it halts it has halted"

"Begin at the beginning, proceed to the end, and then halt."

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

On 2/17/23 9:29 AM, Don Stockbauer wrote:

On Thursday, February 16, 2023 at 5:50:59 PM UTC-6, Richard Damon wrote:

On 2/16/23 9:43 AM, olcott wrote:

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

int main()
{
Output("Input_Halts = ", H(D,D));
Output("Input_Halts = ", D(D));
}

H(D,D) does correctly compute the mapping from its input to its reject
state on the basis that H correctly predicts that D correctly simulated
by H would never halt.

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. >>
D(D) Halts

H(D,D) says Non-Halting and is claimed correct

Therefore H is NOT a Halting Decider, but just a POOP decider (what your
actual criteria is talking about).

"Mommy , when will this system halt?"

"Well, little Felicity , why don't you just take a practical approach , you just sit back and watch it and when it halts it has halted"

"Begin at the beginning, proceed to the end, and then halt."

Actually, because we HAVE his definition of H, we know that D(D) will
halt, and does so as soon as the H(D,D) that it calls has simulated its
input D,D to the point it simulates that call to H(D,D), it will then
return 0 and then D will Halt.

PO gets confused and forgets that he has defined what H does, and
wonders what would happen if it was something different, which it can't
be at this point.

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

On 2/21/2023 10:17 PM, Don Stockbauer wrote:

On Friday, February 17, 2023 at 11:10:24 AM UTC-6, Richard Damon wrote:

On 2/17/23 9:29 AM, Don Stockbauer wrote:

On Thursday, February 16, 2023 at 5:50:59 PM UTC-6, Richard Damon wrote: >>>> On 2/16/23 9:43 AM, olcott wrote:

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

int main()
{
Output("Input_Halts = ", H(D,D));
Output("Input_Halts = ", D(D));
}

H(D,D) does correctly compute the mapping from its input to its reject >>>>> state on the basis that H correctly predicts that D correctly simulated >>>>> by H would never halt.

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.

D(D) Halts

H(D,D) says Non-Halting and is claimed correct

Therefore H is NOT a Halting Decider, but just a POOP decider (what your >>>> actual criteria is talking about).

"Mommy , when will this system halt?"

"Well, little Felicity , why don't you just take a practical approach , you just sit back and watch it and when it halts it has halted"

"Begin at the beginning, proceed to the end, and then halt."

Actually, because we HAVE his definition of H, we know that D(D) will
halt, and does so as soon as the H(D,D) that it calls has simulated its
input D,D to the point it simulates that call to H(D,D), it will then
return 0 and then D will Halt.

PO gets confused and forgets that he has defined what H does, and
wonders what would happen if it was something different, which it can't
be at this point.

I was just giving a practical method for determining halting, which doesn't apply at all to the discussion here.

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

It is a verified fact that H correctly predicts that D correctly
simulated by H would never reach its own final state and terminate
normally, thus H does correctly decide halting for its input D.

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]
[00001d19] 50 push eax // push D
[00001d1a] 8b4d08 mov ecx,[ebp+08]
[00001d1d] 51 push ecx // push D
[00001d1e] e83ff8ffff call 00001562 // call H
[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



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

On Friday, February 17, 2023 at 11:10:24 AM UTC-6, Richard Damon wrote:

On 2/17/23 9:29 AM, Don Stockbauer wrote:

On Thursday, February 16, 2023 at 5:50:59 PM UTC-6, Richard Damon wrote:

On 2/16/23 9:43 AM, olcott wrote:

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

int main()
{
Output("Input_Halts = ", H(D,D));
Output("Input_Halts = ", D(D));
}

H(D,D) does correctly compute the mapping from its input to its reject >>> state on the basis that H correctly predicts that D correctly simulated >>> by H would never halt.

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.

D(D) Halts

H(D,D) says Non-Halting and is claimed correct

Therefore H is NOT a Halting Decider, but just a POOP decider (what your >> actual criteria is talking about).

"Mommy , when will this system halt?"

"Well, little Felicity , why don't you just take a practical approach , you just sit back and watch it and when it halts it has halted"

"Begin at the beginning, proceed to the end, and then halt."

Actually, because we HAVE his definition of H, we know that D(D) will
halt, and does so as soon as the H(D,D) that it calls has simulated its
input D,D to the point it simulates that call to H(D,D), it will then
return 0 and then D will Halt.

PO gets confused and forgets that he has defined what H does, and
wonders what would happen if it was something different, which it can't
be at this point.

I was just giving a practical method for determining halting, which doesn't apply at all to the discussion here.

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

XPost: sci.logic, comp.theory

On 2/23/2023 7:47 PM, Python wrote:

Stupid Idiot Peter Olcott wrote:

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

*D simulated by H cannot possibly correctly reach its ret instruction
and halt*

_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


Although my reviewers are smart enough to see that no D ever stops
running unless H aborts its simulation of D...

These same reviewers are not honest enough to admit that this proves
that H is correct to reject its input D as non-halting.


*Simulating Halt Deciders Defeat the Halting Theorem*
https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem

Ben Bacarrisse: do you still assert that H(P,P) == false is the
"correct" answer even though P(P) halts?

Peter Olcott: Yes that is the correct answer even though P(P) halts.

The fact that no P ever stops running unless H(P,P) aborts its
simulation of its input P conclusively proves that H is correct to
reject its input as non-halting.

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

On 2/23/23 8:50 PM, olcott wrote:

On 2/23/2023 7:47 PM, Python wrote:

Stupid Idiot Peter Olcott wrote:

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

*D simulated by H cannot possibly correctly reach its ret instruction
and halt*

_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


Although my reviewers are smart enough to see that no D ever stops
running unless H aborts its simulation of D...

These same reviewers are not honest enough to admit that this proves
that H is correct to reject its input D as non-halting.


*Simulating Halt Deciders Defeat the Halting Theorem*
https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem

Ben Bacarrisse: do you still assert that H(P,P) == false is the
"correct" answer even though P(P) halts?

Peter Olcott: Yes that is the correct answer even though P(P) halts.

The fact that no P ever stops running unless H(P,P) aborts its
simulation of its input P conclusively proves that H is correct to
reject its input as non-halting.

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.

Thus the fact that P(P) Halts means you have admitted that the actual
correct answer is Halting, and you are just lying that Non-Halting is
the correct answer for the actual Halting Problem.

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