XPost: comp.theory, sci.logic, sci.math

When a simulating halt decider rejects all inputs as non-halting
whenever it correctly detects (in a finite number of steps) that its
correct and complete simulation of its input would never reach the final
state of this input that all [these] inputs (including pathological
inputs) are decided correctly.

*computation that halts* … the Turing machine will halt whenever it
enters a final state. (Linz:1990:234)

Linz, Peter 1990. An Introduction to Formal Languages and Automata. Lexington/Toronto: D. C. Heath and Company. (317-320)

void P(u32 x)
{
if (H(x, x))
HERE: goto HERE;
return;
}

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

_P()
[0000127e](01) 55 push ebp
[0000127f](02) 8bec mov ebp,esp
[00001281](03) 8b4508 mov eax,[ebp+08]
[00001284](01) 50 push eax
[00001285](03) 8b4d08 mov ecx,[ebp+08]
[00001288](01) 51 push ecx
[00001289](05) e820feffff call 000010ae
[0000128e](03) 83c408 add esp,+08
[00001291](02) 85c0 test eax,eax
[00001293](02) 7402 jz 00001297
[00001295](02) ebfe jmp 00001295
[00001297](01) 5d pop ebp
[00001298](01) c3 ret
Size in bytes:(0027) [00001298]

_main()
[0000129e](01) 55 push ebp
[0000129f](02) 8bec mov ebp,esp
[000012a1](05) 687e120000 push 0000127e
[000012a6](05) 687e120000 push 0000127e
[000012ab](05) e8fefdffff call 000010ae
[000012b0](03) 83c408 add esp,+08
[000012b3](01) 50 push eax
[000012b4](05) 680f040000 push 0000040f
[000012b9](05) e8a0f1ffff call 0000045e
[000012be](03) 83c408 add esp,+08
[000012c1](02) 33c0 xor eax,eax
[000012c3](01) 5d pop ebp
[000012c4](01) c3 ret
Size in bytes:(0039) [000012c4]

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= ============= ...[0000129e][0010201f][00000000] 55 push ebp ...[0000129f][0010201f][00000000] 8bec mov ebp,esp ...[000012a1][0010201b][0000127e] 687e120000 push 0000127e // push P ...[000012a6][00102017][0000127e] 687e120000 push 0000127e // push P ...[000012ab][00102013][000012b0] e8fefdffff call 000010ae // call H

*Begin Local Halt Decider Simulation* Execution Trace Stored at:2120d3 ...[0000127e][002120bf][002120c3] 55 push ebp ...[0000127f][002120bf][002120c3] 8bec mov ebp,esp ...[00001281][002120bf][002120c3] 8b4508 mov eax,[ebp+08] ...[00001284][002120bb][0000127e] 50 push eax // push P ...[00001285][002120bb][0000127e] 8b4d08 mov ecx,[ebp+08] ...[00001288][002120b7][0000127e] 51 push ecx // push P ...[00001289][002120b3][0000128e] e820feffff call 000010ae // call H *Infinitely Recursive Simulation Detected Simulation Stopped*

H knows its own machine address and on this basis
H recognizes that P is calling H with its same arguments that it
was called with and there are no instructions preceding this call that
could possibly escape infinitely recursive emulation so H aborts its
emulation of P before P even makes its first call to H.

...[000012b0][0010201f][00000000] 83c408 add esp,+08 ...[000012b3][0010201b][00000000] 50 push eax ...[000012b4][00102017][0000040f] 680f040000 push 0000040f ---[000012b9][00102017][0000040f] e8a0f1ffff call 0000045e
Input_Halts = 0
...[000012be][0010201f][00000000] 83c408 add esp,+08 ...[000012c1][0010201f][00000000] 33c0 xor eax,eax ...[000012c3][00102023][00100000] 5d pop ebp ...[000012c4][00102027][00000004] c3 ret
Number of Instructions Executed(1134) == 17 pages



Halting problem undecidability and infinitely nested simulation (V5)

https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5

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

XPost: comp.theory, sci.logic, sci.math

On 6/17/2022 9:07 PM, olcott wrote:

When a simulating halt decider rejects all inputs as non-halting
whenever it correctly detects (in a finite number of steps) that its
correct and complete simulation of its input would never reach the final state of this input that all [these] inputs (including pathological
inputs) are decided correctly.

*computation that halts* … the Turing machine will halt whenever it
enters a final state. (Linz:1990:234)

Linz, Peter 1990. An Introduction to Formal Languages and Automata. Lexington/Toronto: D. C. Heath and Company. (317-320)

void P(u32 x)
{
  if (H(x, x))
    HERE: goto HERE;
  return;
}

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

_P()
[0000127e](01)  55              push ebp
[0000127f](02)  8bec            mov ebp,esp
[00001281](03)  8b4508          mov eax,[ebp+08]
[00001284](01)  50              push eax
[00001285](03)  8b4d08          mov ecx,[ebp+08]
[00001288](01)  51              push ecx
[00001289](05)  e820feffff      call 000010ae
[0000128e](03)  83c408          add esp,+08
[00001291](02)  85c0            test eax,eax
[00001293](02)  7402            jz 00001297
[00001295](02)  ebfe            jmp 00001295
[00001297](01)  5d              pop ebp
[00001298](01)  c3              ret
Size in bytes:(0027) [00001298]

_main()
[0000129e](01)  55              push ebp
[0000129f](02)  8bec            mov ebp,esp
[000012a1](05)  687e120000      push 0000127e
[000012a6](05)  687e120000      push 0000127e
[000012ab](05)  e8fefdffff      call 000010ae
[000012b0](03)  83c408          add esp,+08
[000012b3](01)  50              push eax
[000012b4](05)  680f040000      push 0000040f
[000012b9](05)  e8a0f1ffff      call 0000045e
[000012be](03)  83c408          add esp,+08
[000012c1](02)  33c0            xor eax,eax
[000012c3](01)  5d              pop ebp
[000012c4](01)  c3              ret
Size in bytes:(0039) [000012c4]

    machine   stack     stack     machine    assembly
    address   address   data      code       language
    ========  ========  ========  =========  ============= ...[0000129e][0010201f][00000000] 55         push ebp ...[0000129f][0010201f][00000000] 8bec       mov ebp,esp ...[000012a1][0010201b][0000127e] 687e120000 push 0000127e // push P ...[000012a6][00102017][0000127e] 687e120000 push 0000127e // push P ...[000012ab][00102013][000012b0] e8fefdffff call 000010ae // call H

*Begin Local Halt Decider Simulation*   Execution Trace Stored at:2120d3 ...[0000127e][002120bf][002120c3] 55         push ebp ...[0000127f][002120bf][002120c3] 8bec       mov ebp,esp ...[00001281][002120bf][002120c3] 8b4508     mov eax,[ebp+08] ...[00001284][002120bb][0000127e] 50         push eax      // push P
...[00001285][002120bb][0000127e] 8b4d08     mov ecx,[ebp+08] ...[00001288][002120b7][0000127e] 51         push ecx      // push P
...[00001289][002120b3][0000128e] e820feffff call 000010ae // call H *Infinitely Recursive Simulation Detected Simulation Stopped*

H knows its own machine address and on this basis:
(a) H recognizes that P is calling H with its same arguments that it was
called with.
(b) There are no instructions in P that could possibly escape this
infinitely recursive emulation.
(c) H aborts its emulation of P before P even makes its first call to H.

...[000012b0][0010201f][00000000] 83c408     add esp,+08 ...[000012b3][0010201b][00000000] 50         push eax ...[000012b4][00102017][0000040f] 680f040000 push 0000040f ---[000012b9][00102017][0000040f] e8a0f1ffff call 0000045e
Input_Halts = 0
...[000012be][0010201f][00000000] 83c408     add esp,+08 ...[000012c1][0010201f][00000000] 33c0       xor eax,eax ...[000012c3][00102023][00100000] 5d         pop ebp ...[000012c4][00102027][00000004] c3         ret
Number of Instructions Executed(1134) == 17 pages

Halting problem undecidability and infinitely nested simulation (V5)

https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5

--
Copyright 2022 Pete 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, sci.math

When a simulating halt decider rejects all inputs as non-halting
whenever it correctly detects (in a finite number of steps) that its
correct and complete simulation of its input would never reach the final
state of this input that all [these] inputs (including pathological
inputs) are decided correctly.

*computation that halts* … the Turing machine will halt whenever it
enters a final state. (Linz:1990:234)

Linz, Peter 1990. An Introduction to Formal Languages and Automata. Lexington/Toronto: D. C. Heath and Company. (317-320)

void P(u32 x)
{
if (H(x, x))
HERE: goto HERE;
return;
}

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

_P()
[0000127e](01) 55 push ebp
[0000127f](02) 8bec mov ebp,esp
[00001281](03) 8b4508 mov eax,[ebp+08]
[00001284](01) 50 push eax
[00001285](03) 8b4d08 mov ecx,[ebp+08]
[00001288](01) 51 push ecx
[00001289](05) e820feffff call 000010ae
[0000128e](03) 83c408 add esp,+08
[00001291](02) 85c0 test eax,eax
[00001293](02) 7402 jz 00001297
[00001295](02) ebfe jmp 00001295
[00001297](01) 5d pop ebp
[00001298](01) c3 ret
Size in bytes:(0027) [00001298]

_main()
[0000129e](01) 55 push ebp
[0000129f](02) 8bec mov ebp,esp
[000012a1](05) 687e120000 push 0000127e
[000012a6](05) 687e120000 push 0000127e
[000012ab](05) e8fefdffff call 000010ae
[000012b0](03) 83c408 add esp,+08
[000012b3](01) 50 push eax
[000012b4](05) 680f040000 push 0000040f
[000012b9](05) e8a0f1ffff call 0000045e
[000012be](03) 83c408 add esp,+08
[000012c1](02) 33c0 xor eax,eax
[000012c3](01) 5d pop ebp
[000012c4](01) c3 ret
Size in bytes:(0039) [000012c4]

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= ============= ...[0000129e][0010201f][00000000] 55 push ebp ...[0000129f][0010201f][00000000] 8bec mov ebp,esp ...[000012a1][0010201b][0000127e] 687e120000 push 0000127e // push P ...[000012a6][00102017][0000127e] 687e120000 push 0000127e // push P ...[000012ab][00102013][000012b0] e8fefdffff call 000010ae // call H

*Begin Local Halt Decider Simulation* Execution Trace Stored at:2120d3 ...[0000127e][002120bf][002120c3] 55 push ebp ...[0000127f][002120bf][002120c3] 8bec mov ebp,esp ...[00001281][002120bf][002120c3] 8b4508 mov eax,[ebp+08] ...[00001284][002120bb][0000127e] 50 push eax // push P ...[00001285][002120bb][0000127e] 8b4d08 mov ecx,[ebp+08] ...[00001288][002120b7][0000127e] 51 push ecx // push P ...[00001289][002120b3][0000128e] e820feffff call 000010ae // call H *Infinitely Recursive Simulation Detected Simulation Stopped*

H knows its own machine address and on this basis
H recognizes that P is calling H with its same arguments that it
was called with and there are no instructions preceding this call that
could possibly escape infinitely recursive emulation so H aborts its
emulation of P before P even makes its first call to H.

...[000012b0][0010201f][00000000] 83c408 add esp,+08 ...[000012b3][0010201b][00000000] 50 push eax ...[000012b4][00102017][0000040f] 680f040000 push 0000040f ---[000012b9][00102017][0000040f] e8a0f1ffff call 0000045e
Input_Halts = 0
...[000012be][0010201f][00000000] 83c408 add esp,+08 ...[000012c1][0010201f][00000000] 33c0 xor eax,eax ...[000012c3][00102023][00100000] 5d pop ebp ...[000012c4][00102027][00000004] c3 ret
Number of Instructions Executed(1134) == 17 pages



Halting problem undecidability and infinitely nested simulation (V5)

https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5

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

XPost: comp.theory, sci.logic, sci.math

On 6/17/2022 9:14 PM, olcott wrote:

On 6/17/2022 9:07 PM, olcott wrote:

When a simulating halt decider rejects all inputs as non-halting
whenever it correctly detects (in a finite number of steps) that its
correct and complete simulation of its input would never reach the
final state of this input that all [these] inputs (including
pathological inputs) are decided correctly.

*computation that halts* … the Turing machine will halt whenever it
enters a final state. (Linz:1990:234)

Linz, Peter 1990. An Introduction to Formal Languages and Automata.
Lexington/Toronto: D. C. Heath and Company. (317-320)

void P(u32 x)
{
   if (H(x, x))
     HERE: goto HERE;
   return;
}

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

_P()
[0000127e](01)  55              push ebp
[0000127f](02)  8bec            mov ebp,esp
[00001281](03)  8b4508          mov eax,[ebp+08]
[00001284](01)  50              push eax
[00001285](03)  8b4d08          mov ecx,[ebp+08]
[00001288](01)  51              push ecx
[00001289](05)  e820feffff      call 000010ae
[0000128e](03)  83c408          add esp,+08
[00001291](02)  85c0            test eax,eax
[00001293](02)  7402            jz 00001297
[00001295](02)  ebfe            jmp 00001295
[00001297](01)  5d              pop ebp
[00001298](01)  c3              ret
Size in bytes:(0027) [00001298]

_main()
[0000129e](01)  55              push ebp
[0000129f](02)  8bec            mov ebp,esp
[000012a1](05)  687e120000      push 0000127e
[000012a6](05)  687e120000      push 0000127e
[000012ab](05)  e8fefdffff      call 000010ae
[000012b0](03)  83c408          add esp,+08
[000012b3](01)  50              push eax
[000012b4](05)  680f040000      push 0000040f
[000012b9](05)  e8a0f1ffff      call 0000045e
[000012be](03)  83c408          add esp,+08
[000012c1](02)  33c0            xor eax,eax
[000012c3](01)  5d              pop ebp
[000012c4](01)  c3              ret
Size in bytes:(0039) [000012c4]

     machine   stack     stack     machine    assembly
     address   address   data      code       language
     ========  ========  ========  =========  =============
...[0000129e][0010201f][00000000] 55         push ebp
...[0000129f][0010201f][00000000] 8bec       mov ebp,esp
...[000012a1][0010201b][0000127e] 687e120000 push 0000127e // push P
...[000012a6][00102017][0000127e] 687e120000 push 0000127e // push P
...[000012ab][00102013][000012b0] e8fefdffff call 000010ae // call H

*Begin Local Halt Decider Simulation*   Execution Trace Stored at:2120d3 >> ...[0000127e][002120bf][002120c3] 55         push ebp
...[0000127f][002120bf][002120c3] 8bec       mov ebp,esp
...[00001281][002120bf][002120c3] 8b4508     mov eax,[ebp+08]
...[00001284][002120bb][0000127e] 50         push eax      // push P
...[00001285][002120bb][0000127e] 8b4d08     mov ecx,[ebp+08]
...[00001288][002120b7][0000127e] 51         push ecx      // push P
...[00001289][002120b3][0000128e] e820feffff call 000010ae // call H
*Infinitely Recursive Simulation Detected Simulation Stopped*

H knows its own machine address and on this basis:
(a) H recognizes that P is calling H with its same arguments that it was called with.
(b) There are no instructions in P that could possibly escape this
infinitely recursive emulation.

(c) H aborts its emulation of P before P its call to H is invoked.

...[000012b0][0010201f][00000000] 83c408     add esp,+08
...[000012b3][0010201b][00000000] 50         push eax
...[000012b4][00102017][0000040f] 680f040000 push 0000040f
---[000012b9][00102017][0000040f] e8a0f1ffff call 0000045e
Input_Halts = 0
...[000012be][0010201f][00000000] 83c408     add esp,+08
...[000012c1][0010201f][00000000] 33c0       xor eax,eax
...[000012c3][00102023][00100000] 5d         pop ebp
...[000012c4][00102027][00000004] c3         ret
Number of Instructions Executed(1134) == 17 pages



Halting problem undecidability and infinitely nested simulation (V5)

https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5

--
Copyright 2022 Pete 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, sci.math

On 6/17/22 10:07 PM, olcott wrote:

When a simulating halt decider rejects all inputs as non-halting
whenever it correctly detects (in a finite number of steps) that its
correct and complete simulation of its input would never reach the final state of this input that all [these] inputs (including pathological
inputs) are decided correctly.

*computation that halts* … the Turing machine will halt whenever it
enters a final state. (Linz:1990:234)

Right, so for H to have CORRECTLY decided non-halting, then the TURING
MACHINE that it was deciding on must not halt. Since H(P,P) is defined
to be deciding on P(P) (or P was built wrong) and since P(P) as a
directly run function returns if H(P,P) returns 0, that can not be a
correct answer.

Your claim that this isn't what H(P,P) means, just says that you lied
that P was built by the Linz formula and your whole proof just becomes a
lie.

Linz, Peter 1990. An Introduction to Formal Languages and Automata. Lexington/Toronto: D. C. Heath and Company. (317-320)

void P(u32 x)
{
  if (H(x, x))
    HERE: goto HERE;
  return;
}

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

_P()
[0000127e](01)  55              push ebp
[0000127f](02)  8bec            mov ebp,esp
[00001281](03)  8b4508          mov eax,[ebp+08]
[00001284](01)  50              push eax
[00001285](03)  8b4d08          mov ecx,[ebp+08]
[00001288](01)  51              push ecx
[00001289](05)  e820feffff      call 000010ae
[0000128e](03)  83c408          add esp,+08
[00001291](02)  85c0            test eax,eax
[00001293](02)  7402            jz 00001297
[00001295](02)  ebfe            jmp 00001295
[00001297](01)  5d              pop ebp
[00001298](01)  c3              ret
Size in bytes:(0027) [00001298]

_main()
[0000129e](01)  55              push ebp
[0000129f](02)  8bec            mov ebp,esp
[000012a1](05)  687e120000      push 0000127e
[000012a6](05)  687e120000      push 0000127e
[000012ab](05)  e8fefdffff      call 000010ae
[000012b0](03)  83c408          add esp,+08
[000012b3](01)  50              push eax
[000012b4](05)  680f040000      push 0000040f
[000012b9](05)  e8a0f1ffff      call 0000045e
[000012be](03)  83c408          add esp,+08
[000012c1](02)  33c0            xor eax,eax
[000012c3](01)  5d              pop ebp
[000012c4](01)  c3              ret
Size in bytes:(0039) [000012c4]

    machine   stack     stack     machine    assembly
    address   address   data      code       language
    ========  ========  ========  =========  ============= ...[0000129e][0010201f][00000000] 55         push ebp ...[0000129f][0010201f][00000000] 8bec       mov ebp,esp ...[000012a1][0010201b][0000127e] 687e120000 push 0000127e // push P ...[000012a6][00102017][0000127e] 687e120000 push 0000127e // push P ...[000012ab][00102013][000012b0] e8fefdffff call 000010ae // call H

*Begin Local Halt Decider Simulation*   Execution Trace Stored at:2120d3 ...[0000127e][002120bf][002120c3] 55         push ebp ...[0000127f][002120bf][002120c3] 8bec       mov ebp,esp ...[00001281][002120bf][002120c3] 8b4508     mov eax,[ebp+08] ...[00001284][002120bb][0000127e] 50         push eax      // push P
...[00001285][002120bb][0000127e] 8b4d08     mov ecx,[ebp+08] ...[00001288][002120b7][0000127e] 51         push ecx      // push P
...[00001289][002120b3][0000128e] e820feffff call 000010ae // call H *Infinitely Recursive Simulation Detected Simulation Stopped*

H knows its own machine address and on this basis
H recognizes that P is calling H with its same arguments that it
was called with and there are no instructions preceding this call that
could possibly escape infinitely recursive emulation so H aborts its emulation of P before P even makes its first call to H.

But that isn't the criteria. The criteria is will the funtion provided
as an input return when called with the second parameter.

It doesn't matter that the code in the C function doesn't have any
stopping code, it is enough that H contains it, since that H is part of
the mathematical/computatinal function P and part of its behaivor.

If H doesn't have a condition to stop it, the H fails to be a decider.

Which way does H fail?

...[000012b0][0010201f][00000000] 83c408     add esp,+08 ...[000012b3][0010201b][00000000] 50         push eax ...[000012b4][00102017][0000040f] 680f040000 push 0000040f ---[000012b9][00102017][0000040f] e8a0f1ffff call 0000045e
Input_Halts = 0
...[000012be][0010201f][00000000] 83c408     add esp,+08 ...[000012c1][0010201f][00000000] 33c0       xor eax,eax ...[000012c3][00102023][00100000] 5d         pop ebp ...[000012c4][00102027][00000004] c3         ret
Number of Instructions Executed(1134) == 17 pages

Halting problem undecidability and infinitely nested simulation (V5)

https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5

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

XPost: comp.theory, sci.logic, sci.math

On Fri, 17 Jun 2022 21:07:31 -0500
olcott <NoOne@NoWhere.com> wrote:

When a simulating halt decider rejects all inputs as non-halting
whenever it correctly detects (in a finite number of steps) that its
correct and complete simulation of its input would never reach the
final state of this input that all [these] inputs (including
pathological inputs) are decided correctly.

*computation that halts* … the Turing machine will halt whenever it
enters a final state. (Linz:1990:234)

Linz, Peter 1990. An Introduction to Formal Languages and Automata. Lexington/Toronto: D. C. Heath and Company. (317-320)

void P(u32 x)
{
if (H(x, x))
HERE: goto HERE;
return;
}

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

_P()
[0000127e](01) 55 push ebp
[0000127f](02) 8bec mov ebp,esp
[00001281](03) 8b4508 mov eax,[ebp+08]
[00001284](01) 50 push eax
[00001285](03) 8b4d08 mov ecx,[ebp+08]
[00001288](01) 51 push ecx
[00001289](05) e820feffff call 000010ae
[0000128e](03) 83c408 add esp,+08
[00001291](02) 85c0 test eax,eax
[00001293](02) 7402 jz 00001297
[00001295](02) ebfe jmp 00001295
[00001297](01) 5d pop ebp
[00001298](01) c3 ret
Size in bytes:(0027) [00001298]

_main()
[0000129e](01) 55 push ebp
[0000129f](02) 8bec mov ebp,esp
[000012a1](05) 687e120000 push 0000127e
[000012a6](05) 687e120000 push 0000127e
[000012ab](05) e8fefdffff call 000010ae
[000012b0](03) 83c408 add esp,+08
[000012b3](01) 50 push eax
[000012b4](05) 680f040000 push 0000040f
[000012b9](05) e8a0f1ffff call 0000045e
[000012be](03) 83c408 add esp,+08
[000012c1](02) 33c0 xor eax,eax
[000012c3](01) 5d pop ebp
[000012c4](01) c3 ret
Size in bytes:(0039) [000012c4]

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= ============= ...[0000129e][0010201f][00000000] 55 push ebp ...[0000129f][0010201f][00000000] 8bec mov ebp,esp ...[000012a1][0010201b][0000127e] 687e120000 push 0000127e // push P ...[000012a6][00102017][0000127e] 687e120000 push 0000127e // push P ...[000012ab][00102013][000012b0] e8fefdffff call 000010ae // call H

*Begin Local Halt Decider Simulation* Execution Trace Stored
at:2120d3 ...[0000127e][002120bf][002120c3] 55 push ebp ...[0000127f][002120bf][002120c3] 8bec mov ebp,esp ...[00001281][002120bf][002120c3] 8b4508 mov eax,[ebp+08] ...[00001284][002120bb][0000127e] 50 push eax // push P ...[00001285][002120bb][0000127e] 8b4d08 mov ecx,[ebp+08] ...[00001288][002120b7][0000127e] 51 push ecx // push P ...[00001289][002120b3][0000128e] e820feffff call 000010ae // call H *Infinitely Recursive Simulation Detected Simulation Stopped*

H knows its own machine address and on this basis
H recognizes that P is calling H with its same arguments that it
was called with and there are no instructions preceding this call that
could possibly escape infinitely recursive emulation so H aborts its emulation of P before P even makes its first call to H.

...[000012b0][0010201f][00000000] 83c408 add esp,+08 ...[000012b3][0010201b][00000000] 50 push eax ...[000012b4][00102017][0000040f] 680f040000 push 0000040f ---[000012b9][00102017][0000040f] e8a0f1ffff call 0000045e
Input_Halts = 0
...[000012be][0010201f][00000000] 83c408 add esp,+08 ...[000012c1][0010201f][00000000] 33c0 xor eax,eax ...[000012c3][00102023][00100000] 5d pop ebp ...[000012c4][00102027][00000004] c3 ret
Number of Instructions Executed(1134) == 17 pages

Halting problem undecidability and infinitely nested simulation (V5)

https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5

void Px(u32 x)
{
H(x, x);
return;
}

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

...[000013e8][00102357][00000000] 83c408 add esp,+08 ...[000013eb][00102353][00000000] 50 push eax ...[000013ec][0010234f][00000427] 6827040000 push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08 ...[000013f9][00102357][00000000] 33c0 xor eax,eax ...[000013fb][0010235b][00100000] 5d pop ebp ...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)

It gets the answer wrong, i.e. input has not been decided correctly.
QED.

/Flibble

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

XPost: comp.theory, sci.logic, sci.math

On 6/18/2022 8:23 AM, Mr Flibble wrote:

On Fri, 17 Jun 2022 21:07:31 -0500
olcott <NoOne@NoWhere.com> wrote:

When a simulating halt decider rejects all inputs as non-halting
whenever it correctly detects (in a finite number of steps) that its
correct and complete simulation of its input would never reach the
final state of this input that all [these] inputs (including
pathological inputs) are decided correctly.

*computation that halts* … the Turing machine will halt whenever it
enters a final state. (Linz:1990:234)

Linz, Peter 1990. An Introduction to Formal Languages and Automata.
Lexington/Toronto: D. C. Heath and Company. (317-320)

void P(u32 x)
{
if (H(x, x))
HERE: goto HERE;
return;
}

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

_P()
[0000127e](01) 55 push ebp
[0000127f](02) 8bec mov ebp,esp
[00001281](03) 8b4508 mov eax,[ebp+08]
[00001284](01) 50 push eax
[00001285](03) 8b4d08 mov ecx,[ebp+08]
[00001288](01) 51 push ecx
[00001289](05) e820feffff call 000010ae
[0000128e](03) 83c408 add esp,+08
[00001291](02) 85c0 test eax,eax
[00001293](02) 7402 jz 00001297
[00001295](02) ebfe jmp 00001295
[00001297](01) 5d pop ebp
[00001298](01) c3 ret
Size in bytes:(0027) [00001298]

_main()
[0000129e](01) 55 push ebp
[0000129f](02) 8bec mov ebp,esp
[000012a1](05) 687e120000 push 0000127e
[000012a6](05) 687e120000 push 0000127e
[000012ab](05) e8fefdffff call 000010ae
[000012b0](03) 83c408 add esp,+08
[000012b3](01) 50 push eax
[000012b4](05) 680f040000 push 0000040f
[000012b9](05) e8a0f1ffff call 0000045e
[000012be](03) 83c408 add esp,+08
[000012c1](02) 33c0 xor eax,eax
[000012c3](01) 5d pop ebp
[000012c4](01) c3 ret
Size in bytes:(0039) [000012c4]

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
...[0000129e][0010201f][00000000] 55 push ebp
...[0000129f][0010201f][00000000] 8bec mov ebp,esp
...[000012a1][0010201b][0000127e] 687e120000 push 0000127e // push P
...[000012a6][00102017][0000127e] 687e120000 push 0000127e // push P
...[000012ab][00102013][000012b0] e8fefdffff call 000010ae // call H

*Begin Local Halt Decider Simulation* Execution Trace Stored
at:2120d3 ...[0000127e][002120bf][002120c3] 55 push ebp
...[0000127f][002120bf][002120c3] 8bec mov ebp,esp
...[00001281][002120bf][002120c3] 8b4508 mov eax,[ebp+08]
...[00001284][002120bb][0000127e] 50 push eax // push P
...[00001285][002120bb][0000127e] 8b4d08 mov ecx,[ebp+08]
...[00001288][002120b7][0000127e] 51 push ecx // push P
...[00001289][002120b3][0000128e] e820feffff call 000010ae // call H
*Infinitely Recursive Simulation Detected Simulation Stopped*

H knows its own machine address and on this basis
H recognizes that P is calling H with its same arguments that it
was called with and there are no instructions preceding this call that
could possibly escape infinitely recursive emulation so H aborts its
emulation of P before P even makes its first call to H.

...[000012b0][0010201f][00000000] 83c408 add esp,+08
...[000012b3][0010201b][00000000] 50 push eax
...[000012b4][00102017][0000040f] 680f040000 push 0000040f
---[000012b9][00102017][0000040f] e8a0f1ffff call 0000045e
Input_Halts = 0
...[000012be][0010201f][00000000] 83c408 add esp,+08
...[000012c1][0010201f][00000000] 33c0 xor eax,eax
...[000012c3][00102023][00100000] 5d pop ebp
...[000012c4][00102027][00000004] c3 ret
Number of Instructions Executed(1134) == 17 pages



Halting problem undecidability and infinitely nested simulation (V5)

https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5

void Px(u32 x)
{
H(x, x);
return;
}

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

...[000013e8][00102357][00000000] 83c408 add esp,+08 ...[000013eb][00102353][00000000] 50 push eax ...[000013ec][0010234f][00000427] 6827040000 push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08 ...[000013f9][00102357][00000000] 33c0 xor eax,eax ...[000013fb][0010235b][00100000] 5d pop ebp ...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)

It gets the answer wrong, i.e. input has not been decided correctly.
QED.

/Flibble

(X) H(P,P) correctly determines (in a finite number of steps) that the
correct and complete x86 emulation of its input would never reach the
"ret" instruction (AKA final state) of this input.

(Y) computation that halts … the Turing machine will halt whenever it
enters a final state. (Linz:1990:234)

(Z) H(P,P) has correctly determined that its input is non-halting.

When we know that X & Y proves Z and we know X & Y then Z is proved.
*Failing to agree with this last line is sufficient evidence of dishonesty*



Linz, Peter 1990. An Introduction to Formal Languages and Automata. Lexington/Toronto: D. C. Heath and Company. (317-320)


--
Copyright 2022 Pete 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, sci.math

On Sat, 18 Jun 2022 08:35:36 -0500
olcott <NoOne@NoWhere.com> wrote:

On 6/18/2022 8:23 AM, Mr Flibble wrote:

On Fri, 17 Jun 2022 21:07:31 -0500
olcott <NoOne@NoWhere.com> wrote:

When a simulating halt decider rejects all inputs as non-halting
whenever it correctly detects (in a finite number of steps) that
its correct and complete simulation of its input would never reach
the final state of this input that all [these] inputs (including
pathological inputs) are decided correctly.

*computation that halts* … the Turing machine will halt whenever it
enters a final state. (Linz:1990:234)

Linz, Peter 1990. An Introduction to Formal Languages and Automata.
Lexington/Toronto: D. C. Heath and Company. (317-320)

void P(u32 x)
{
if (H(x, x))
HERE: goto HERE;
return;
}

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

_P()
[0000127e](01) 55 push ebp
[0000127f](02) 8bec mov ebp,esp
[00001281](03) 8b4508 mov eax,[ebp+08]
[00001284](01) 50 push eax
[00001285](03) 8b4d08 mov ecx,[ebp+08]
[00001288](01) 51 push ecx
[00001289](05) e820feffff call 000010ae
[0000128e](03) 83c408 add esp,+08
[00001291](02) 85c0 test eax,eax
[00001293](02) 7402 jz 00001297
[00001295](02) ebfe jmp 00001295
[00001297](01) 5d pop ebp
[00001298](01) c3 ret
Size in bytes:(0027) [00001298]

_main()
[0000129e](01) 55 push ebp
[0000129f](02) 8bec mov ebp,esp
[000012a1](05) 687e120000 push 0000127e
[000012a6](05) 687e120000 push 0000127e
[000012ab](05) e8fefdffff call 000010ae
[000012b0](03) 83c408 add esp,+08
[000012b3](01) 50 push eax
[000012b4](05) 680f040000 push 0000040f
[000012b9](05) e8a0f1ffff call 0000045e
[000012be](03) 83c408 add esp,+08
[000012c1](02) 33c0 xor eax,eax
[000012c3](01) 5d pop ebp
[000012c4](01) c3 ret
Size in bytes:(0039) [000012c4]

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
...[0000129e][0010201f][00000000] 55 push ebp
...[0000129f][0010201f][00000000] 8bec mov ebp,esp
...[000012a1][0010201b][0000127e] 687e120000 push 0000127e // push
P ...[000012a6][00102017][0000127e] 687e120000 push 0000127e //
push P ...[000012ab][00102013][000012b0] e8fefdffff call 000010ae
// call H

*Begin Local Halt Decider Simulation* Execution Trace Stored
at:2120d3 ...[0000127e][002120bf][002120c3] 55 push ebp
...[0000127f][002120bf][002120c3] 8bec mov ebp,esp
...[00001281][002120bf][002120c3] 8b4508 mov eax,[ebp+08]
...[00001284][002120bb][0000127e] 50 push eax // push
P ...[00001285][002120bb][0000127e] 8b4d08 mov ecx,[ebp+08]
...[00001288][002120b7][0000127e] 51 push ecx // push
P ...[00001289][002120b3][0000128e] e820feffff call 000010ae //
call H *Infinitely Recursive Simulation Detected Simulation
Stopped*

H knows its own machine address and on this basis
H recognizes that P is calling H with its same arguments that it
was called with and there are no instructions preceding this call
that could possibly escape infinitely recursive emulation so H
aborts its emulation of P before P even makes its first call to H.

...[000012b0][0010201f][00000000] 83c408 add esp,+08
...[000012b3][0010201b][00000000] 50 push eax
...[000012b4][00102017][0000040f] 680f040000 push 0000040f
---[000012b9][00102017][0000040f] e8a0f1ffff call 0000045e
Input_Halts = 0
...[000012be][0010201f][00000000] 83c408 add esp,+08
...[000012c1][0010201f][00000000] 33c0 xor eax,eax
...[000012c3][00102023][00100000] 5d pop ebp
...[000012c4][00102027][00000004] c3 ret
Number of Instructions Executed(1134) == 17 pages



Halting problem undecidability and infinitely nested simulation
(V5)

https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5

void Px(u32 x)
{
H(x, x);
return;
}

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

...[000013e8][00102357][00000000] 83c408 add esp,+08 ...[000013eb][00102353][00000000] 50 push eax ...[000013ec][0010234f][00000427] 6827040000 push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08 ...[000013f9][00102357][00000000] 33c0 xor eax,eax ...[000013fb][0010235b][00100000] 5d pop ebp ...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)

It gets the answer wrong, i.e. input has not been decided correctly.
QED.

/Flibble

(X) H(P,P) correctly determines (in a finite number of steps) that
the correct and complete x86 emulation of its input would never reach
the "ret" instruction (AKA final state) of this input.

(Y) computation that halts … the Turing machine will halt whenever it enters a final state. (Linz:1990:234)

(Z) H(P,P) has correctly determined that its input is non-halting.

When we know that X & Y proves Z and we know X & Y then Z is proved.
*Failing to agree with this last line is sufficient evidence of
dishonesty*

Linz, Peter 1990. An Introduction to Formal Languages and Automata. Lexington/Toronto: D. C. Heath and Company. (317-320)

It gets the answer wrong, i.e. input has not been decided correctly.
QED.

/Flibble

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

XPost: comp.theory, sci.logic, sci.math

On 6/18/2022 8:53 AM, Mr Flibble wrote:

On Sat, 18 Jun 2022 08:35:36 -0500
olcott <NoOne@NoWhere.com> wrote:

On 6/18/2022 8:23 AM, Mr Flibble wrote:

On Fri, 17 Jun 2022 21:07:31 -0500
olcott <NoOne@NoWhere.com> wrote:

When a simulating halt decider rejects all inputs as non-halting
whenever it correctly detects (in a finite number of steps) that
its correct and complete simulation of its input would never reach
the final state of this input that all [these] inputs (including
pathological inputs) are decided correctly.

*computation that halts* … the Turing machine will halt whenever it
enters a final state. (Linz:1990:234)

Linz, Peter 1990. An Introduction to Formal Languages and Automata.
Lexington/Toronto: D. C. Heath and Company. (317-320)

void P(u32 x)
{
if (H(x, x))
HERE: goto HERE;
return;
}

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

_P()
[0000127e](01) 55 push ebp
[0000127f](02) 8bec mov ebp,esp
[00001281](03) 8b4508 mov eax,[ebp+08]
[00001284](01) 50 push eax
[00001285](03) 8b4d08 mov ecx,[ebp+08]
[00001288](01) 51 push ecx
[00001289](05) e820feffff call 000010ae
[0000128e](03) 83c408 add esp,+08
[00001291](02) 85c0 test eax,eax
[00001293](02) 7402 jz 00001297
[00001295](02) ebfe jmp 00001295
[00001297](01) 5d pop ebp
[00001298](01) c3 ret
Size in bytes:(0027) [00001298]

_main()
[0000129e](01) 55 push ebp
[0000129f](02) 8bec mov ebp,esp
[000012a1](05) 687e120000 push 0000127e
[000012a6](05) 687e120000 push 0000127e
[000012ab](05) e8fefdffff call 000010ae
[000012b0](03) 83c408 add esp,+08
[000012b3](01) 50 push eax
[000012b4](05) 680f040000 push 0000040f
[000012b9](05) e8a0f1ffff call 0000045e
[000012be](03) 83c408 add esp,+08
[000012c1](02) 33c0 xor eax,eax
[000012c3](01) 5d pop ebp
[000012c4](01) c3 ret
Size in bytes:(0039) [000012c4]

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
...[0000129e][0010201f][00000000] 55 push ebp
...[0000129f][0010201f][00000000] 8bec mov ebp,esp
...[000012a1][0010201b][0000127e] 687e120000 push 0000127e // push
P ...[000012a6][00102017][0000127e] 687e120000 push 0000127e //
push P ...[000012ab][00102013][000012b0] e8fefdffff call 000010ae
// call H

*Begin Local Halt Decider Simulation* Execution Trace Stored
at:2120d3 ...[0000127e][002120bf][002120c3] 55 push ebp
...[0000127f][002120bf][002120c3] 8bec mov ebp,esp
...[00001281][002120bf][002120c3] 8b4508 mov eax,[ebp+08]
...[00001284][002120bb][0000127e] 50 push eax // push
P ...[00001285][002120bb][0000127e] 8b4d08 mov ecx,[ebp+08]
...[00001288][002120b7][0000127e] 51 push ecx // push
P ...[00001289][002120b3][0000128e] e820feffff call 000010ae //
call H *Infinitely Recursive Simulation Detected Simulation
Stopped*

H knows its own machine address and on this basis
H recognizes that P is calling H with its same arguments that it
was called with and there are no instructions preceding this call
that could possibly escape infinitely recursive emulation so H
aborts its emulation of P before P even makes its first call to H.

...[000012b0][0010201f][00000000] 83c408 add esp,+08
...[000012b3][0010201b][00000000] 50 push eax
...[000012b4][00102017][0000040f] 680f040000 push 0000040f
---[000012b9][00102017][0000040f] e8a0f1ffff call 0000045e
Input_Halts = 0
...[000012be][0010201f][00000000] 83c408 add esp,+08
...[000012c1][0010201f][00000000] 33c0 xor eax,eax
...[000012c3][00102023][00100000] 5d pop ebp
...[000012c4][00102027][00000004] c3 ret
Number of Instructions Executed(1134) == 17 pages



Halting problem undecidability and infinitely nested simulation
(V5)

https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5

void Px(u32 x)
{
H(x, x);
return;
}

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

...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)

It gets the answer wrong, i.e. input has not been decided correctly.
QED.

/Flibble

(X) H(P,P) correctly determines (in a finite number of steps) that
the correct and complete x86 emulation of its input would never reach
the "ret" instruction (AKA final state) of this input.

(Y) computation that halts … the Turing machine will halt whenever it
enters a final state. (Linz:1990:234)

(Z) H(P,P) has correctly determined that its input is non-halting.

When we know that X & Y proves Z and we know X & Y then Z is proved.
*Failing to agree with this last line is sufficient evidence of
dishonesty*



Linz, Peter 1990. An Introduction to Formal Languages and Automata.
Lexington/Toronto: D. C. Heath and Company. (317-320)

It gets the answer wrong, i.e. input has not been decided correctly.
QED.

/Flibble

When we know that X & Y proves Z and we know X & Y then Z is proved.
*Failing to agree with this last line is sufficient evidence of dishonesty*

Sufficient evidence of dishonesty!


--
Copyright 2022 Pete 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, sci.math

On 6/18/22 9:59 AM, olcott wrote:

On 6/18/2022 8:53 AM, Mr Flibble wrote:

On Sat, 18 Jun 2022 08:35:36 -0500
olcott <NoOne@NoWhere.com> wrote:

On 6/18/2022 8:23 AM, Mr Flibble wrote:

On Fri, 17 Jun 2022 21:07:31 -0500
olcott <NoOne@NoWhere.com> wrote:

When a simulating halt decider rejects all inputs as non-halting
whenever it correctly detects (in a finite number of steps) that
its correct and complete simulation of its input would never reach
the final state of this input that all [these] inputs (including
pathological inputs) are decided correctly.

*computation that halts* … the Turing machine will halt whenever it >>>>> enters a final state. (Linz:1990:234)

Linz, Peter 1990. An Introduction to Formal Languages and Automata.
Lexington/Toronto: D. C. Heath and Company. (317-320)

void P(u32 x)
{
     if (H(x, x))
       HERE: goto HERE;
     return;
}

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

_P()
[0000127e](01)  55              push ebp
[0000127f](02)  8bec            mov ebp,esp
[00001281](03)  8b4508          mov eax,[ebp+08]
[00001284](01)  50              push eax
[00001285](03)  8b4d08          mov ecx,[ebp+08]
[00001288](01)  51              push ecx
[00001289](05)  e820feffff      call 000010ae
[0000128e](03)  83c408          add esp,+08
[00001291](02)  85c0            test eax,eax
[00001293](02)  7402            jz 00001297
[00001295](02)  ebfe            jmp 00001295
[00001297](01)  5d              pop ebp
[00001298](01)  c3              ret
Size in bytes:(0027) [00001298]

_main()
[0000129e](01)  55              push ebp
[0000129f](02)  8bec            mov ebp,esp
[000012a1](05)  687e120000      push 0000127e
[000012a6](05)  687e120000      push 0000127e
[000012ab](05)  e8fefdffff      call 000010ae
[000012b0](03)  83c408          add esp,+08
[000012b3](01)  50              push eax
[000012b4](05)  680f040000      push 0000040f
[000012b9](05)  e8a0f1ffff      call 0000045e
[000012be](03)  83c408          add esp,+08
[000012c1](02)  33c0            xor eax,eax
[000012c3](01)  5d              pop ebp
[000012c4](01)  c3              ret
Size in bytes:(0039) [000012c4]

       machine   stack     stack     machine    assembly
       address   address   data      code       language
       ========  ========  ========  =========  ============= >>>>> ...[0000129e][0010201f][00000000] 55         push ebp
...[0000129f][0010201f][00000000] 8bec       mov ebp,esp
...[000012a1][0010201b][0000127e] 687e120000 push 0000127e // push
P ...[000012a6][00102017][0000127e] 687e120000 push 0000127e //
push P ...[000012ab][00102013][000012b0] e8fefdffff call 000010ae
// call H

*Begin Local Halt Decider Simulation*   Execution Trace Stored
at:2120d3 ...[0000127e][002120bf][002120c3] 55         push ebp >>>>> ...[0000127f][002120bf][002120c3] 8bec       mov ebp,esp
...[00001281][002120bf][002120c3] 8b4508     mov eax,[ebp+08]
...[00001284][002120bb][0000127e] 50         push eax      // push
P ...[00001285][002120bb][0000127e] 8b4d08     mov ecx,[ebp+08]
...[00001288][002120b7][0000127e] 51         push ecx      // push
P ...[00001289][002120b3][0000128e] e820feffff call 000010ae //
call H *Infinitely Recursive Simulation Detected Simulation
Stopped*

H knows its own machine address and on this basis
H recognizes that P is calling H with its same arguments that it
was called with and there are no instructions preceding this call
that could possibly escape infinitely recursive emulation so H
aborts its emulation of P before P even makes its first call to H.

...[000012b0][0010201f][00000000] 83c408     add esp,+08
...[000012b3][0010201b][00000000] 50         push eax
...[000012b4][00102017][0000040f] 680f040000 push 0000040f
---[000012b9][00102017][0000040f] e8a0f1ffff call 0000045e
Input_Halts = 0
...[000012be][0010201f][00000000] 83c408     add esp,+08
...[000012c1][0010201f][00000000] 33c0       xor eax,eax
...[000012c3][00102023][00100000] 5d         pop ebp
...[000012c4][00102027][00000004] c3         ret
Number of Instructions Executed(1134) == 17 pages



Halting problem undecidability and infinitely nested simulation
(V5)

https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5

void Px(u32 x)
{
     H(x, x);
     return;
}

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

...[000013e8][00102357][00000000] 83c408          add esp,+08 >>>> ...[000013eb][00102353][00000000] 50              push eax >>>> ...[000013ec][0010234f][00000427] 6827040000      push 00000427
---[000013f1][0010234f][00000427] e880f0ffff      call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408          add esp,+08 >>>> ...[000013f9][00102357][00000000] 33c0            xor eax,eax >>>> ...[000013fb][0010235b][00100000] 5d              pop ebp >>>> ...[000013fc][0010235f][00000004] c3              ret
Number of Instructions Executed(16120)

It gets the answer wrong, i.e. input has not been decided correctly.
QED.

/Flibble

(X) H(P,P) correctly determines (in a finite number of steps) that
the correct and complete x86 emulation of its input would never reach
the "ret" instruction (AKA final state) of this input.

(Y) computation that halts … the Turing machine will halt whenever it
enters a final state. (Linz:1990:234)

(Z) H(P,P) has correctly determined that its input is non-halting.

When we know that X & Y proves Z and we know X & Y then Z is proved.
*Failing to agree with this last line is sufficient evidence of
dishonesty*



Linz, Peter 1990. An Introduction to Formal Languages and Automata.
Lexington/Toronto: D. C. Heath and Company. (317-320)

It gets the answer wrong, i.e. input has not been decided correctly.
QED.

/Flibble

When we know that X & Y proves Z and we know X & Y then Z is proved.
*Failing to agree with this last line is sufficient evidence of dishonesty*

Sufficient evidence of dishonesty!

Except that you haven't actually established X, not for the H that you
are talking about no, so you are the one being dishonest to claim it.

You are being intentionally deceitful by calling two different
algorithms the same name, and ignoring that they are actually different algorithms.

You have the H that is really Hn that never aborts, but is a pure
emulator, and you have the H that is really Ha that does abort and
assumes that the P it is given that is supposed to be calling Ha is
actually calling Hn, and thus either H isn't a pure functions as it
switches between the algorithm of Hn and Ha depending on things not part
of its input, or it isn't based on a correct emulation as it "sees" Ha
as Hn.

FAIL.

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

XPost: comp.theory, sci.logic, sci.math

On 6/17/2022 9:07 PM, olcott wrote:

When a simulating halt decider rejects all inputs as non-halting
whenever it correctly detects (in a finite number of steps) that its
correct and complete simulation of its input would never reach the final state of this input that all [these] inputs (including pathological
inputs) are decided correctly.

*computation that halts* … the Turing machine will halt whenever it
enters a final state. (Linz:1990:234)

Linz, Peter 1990. An Introduction to Formal Languages and Automata. Lexington/Toronto: D. C. Heath and Company. (317-320)

void P(u32 x)
{
  if (H(x, x))
    HERE: goto HERE;
  return;
}

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

_P()
[0000127e](01)  55              push ebp
[0000127f](02)  8bec            mov ebp,esp
[00001281](03)  8b4508          mov eax,[ebp+08]
[00001284](01)  50              push eax
[00001285](03)  8b4d08          mov ecx,[ebp+08]
[00001288](01)  51              push ecx
[00001289](05)  e820feffff      call 000010ae
[0000128e](03)  83c408          add esp,+08
[00001291](02)  85c0            test eax,eax
[00001293](02)  7402            jz 00001297
[00001295](02)  ebfe            jmp 00001295
[00001297](01)  5d              pop ebp
[00001298](01)  c3              ret
Size in bytes:(0027) [00001298]

_main()
[0000129e](01)  55              push ebp
[0000129f](02)  8bec            mov ebp,esp
[000012a1](05)  687e120000      push 0000127e
[000012a6](05)  687e120000      push 0000127e
[000012ab](05)  e8fefdffff      call 000010ae
[000012b0](03)  83c408          add esp,+08
[000012b3](01)  50              push eax
[000012b4](05)  680f040000      push 0000040f
[000012b9](05)  e8a0f1ffff      call 0000045e
[000012be](03)  83c408          add esp,+08
[000012c1](02)  33c0            xor eax,eax
[000012c3](01)  5d              pop ebp
[000012c4](01)  c3              ret
Size in bytes:(0039) [000012c4]

    machine   stack     stack     machine    assembly
    address   address   data      code       language
    ========  ========  ========  =========  ============= ...[0000129e][0010201f][00000000] 55         push ebp ...[0000129f][0010201f][00000000] 8bec       mov ebp,esp ...[000012a1][0010201b][0000127e] 687e120000 push 0000127e // push P ...[000012a6][00102017][0000127e] 687e120000 push 0000127e // push P ...[000012ab][00102013][000012b0] e8fefdffff call 000010ae // call H

*Begin Local Halt Decider Simulation*   Execution Trace Stored at:2120d3 ...[0000127e][002120bf][002120c3] 55         push ebp ...[0000127f][002120bf][002120c3] 8bec       mov ebp,esp ...[00001281][002120bf][002120c3] 8b4508     mov eax,[ebp+08] ...[00001284][002120bb][0000127e] 50         push eax      // push P
...[00001285][002120bb][0000127e] 8b4d08     mov ecx,[ebp+08] ...[00001288][002120b7][0000127e] 51         push ecx      // push P
...[00001289][002120b3][0000128e] e820feffff call 000010ae // call H *Infinitely Recursive Simulation Detected Simulation Stopped*

H knows its own machine address and on this basis
H recognizes that P is calling H with its same arguments that it
was called with and there are no instructions preceding this call that
could possibly escape infinitely recursive emulation so H aborts its emulation of P before P even makes its first call to H.

...[000012b0][0010201f][00000000] 83c408     add esp,+08 ...[000012b3][0010201b][00000000] 50         push eax ...[000012b4][00102017][0000040f] 680f040000 push 0000040f ---[000012b9][00102017][0000040f] e8a0f1ffff call 0000045e
Input_Halts = 0
...[000012be][0010201f][00000000] 83c408     add esp,+08 ...[000012c1][0010201f][00000000] 33c0       xor eax,eax ...[000012c3][00102023][00100000] 5d         pop ebp ...[000012c4][00102027][00000004] c3         ret
Number of Instructions Executed(1134) == 17 pages

Halting problem undecidability and infinitely nested simulation (V5)

https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5

All of the code including several halt deciders that use different
methods for pathological inputs and take 0,1,2 arguments, along with the complete x86 emulator fits in a 131K zip file and is configured as a
visual studio project. *I just got this done right now*

The prior pathological input decider required static local data that was
stored directly in the function body. it construed infinitely nested
simulation as infinite recursion.

The current pathological input decider is a pure function of its inputs.
The infinite loop and infinite recursion deciders remain the same.

This is the the design of the pathological input decider :

H knows its own machine address and on this basis:
(a) H recognizes that P is calling H with the same arguments that H was
called with.
(b) There are no instructions in P that could possibly escape this
infinitely recursive emulation.
(c) H aborts its emulation of P before P its call to H is invoked.


--
Copyright 2022 Pete 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, sci.math

On 6/19/22 2:24 PM, olcott wrote:

On 6/17/2022 9:07 PM, olcott wrote:

When a simulating halt decider rejects all inputs as non-halting
whenever it correctly detects (in a finite number of steps) that its
correct and complete simulation of its input would never reach the
final state of this input that all [these] inputs (including
pathological inputs) are decided correctly.

*computation that halts* … the Turing machine will halt whenever it
enters a final state. (Linz:1990:234)

Linz, Peter 1990. An Introduction to Formal Languages and Automata.
Lexington/Toronto: D. C. Heath and Company. (317-320)

void P(u32 x)
{
   if (H(x, x))
     HERE: goto HERE;
   return;
}

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

_P()
[0000127e](01)  55              push ebp
[0000127f](02)  8bec            mov ebp,esp
[00001281](03)  8b4508          mov eax,[ebp+08]
[00001284](01)  50              push eax
[00001285](03)  8b4d08          mov ecx,[ebp+08]
[00001288](01)  51              push ecx
[00001289](05)  e820feffff      call 000010ae
[0000128e](03)  83c408          add esp,+08
[00001291](02)  85c0            test eax,eax
[00001293](02)  7402            jz 00001297
[00001295](02)  ebfe            jmp 00001295
[00001297](01)  5d              pop ebp
[00001298](01)  c3              ret
Size in bytes:(0027) [00001298]

_main()
[0000129e](01)  55              push ebp
[0000129f](02)  8bec            mov ebp,esp
[000012a1](05)  687e120000      push 0000127e
[000012a6](05)  687e120000      push 0000127e
[000012ab](05)  e8fefdffff      call 000010ae
[000012b0](03)  83c408          add esp,+08
[000012b3](01)  50              push eax
[000012b4](05)  680f040000      push 0000040f
[000012b9](05)  e8a0f1ffff      call 0000045e
[000012be](03)  83c408          add esp,+08
[000012c1](02)  33c0            xor eax,eax
[000012c3](01)  5d              pop ebp
[000012c4](01)  c3              ret
Size in bytes:(0039) [000012c4]

     machine   stack     stack     machine    assembly
     address   address   data      code       language
     ========  ========  ========  =========  =============
...[0000129e][0010201f][00000000] 55         push ebp
...[0000129f][0010201f][00000000] 8bec       mov ebp,esp
...[000012a1][0010201b][0000127e] 687e120000 push 0000127e // push P
...[000012a6][00102017][0000127e] 687e120000 push 0000127e // push P
...[000012ab][00102013][000012b0] e8fefdffff call 000010ae // call H

*Begin Local Halt Decider Simulation*   Execution Trace Stored at:2120d3 >> ...[0000127e][002120bf][002120c3] 55         push ebp
...[0000127f][002120bf][002120c3] 8bec       mov ebp,esp
...[00001281][002120bf][002120c3] 8b4508     mov eax,[ebp+08]
...[00001284][002120bb][0000127e] 50         push eax      // push P
...[00001285][002120bb][0000127e] 8b4d08     mov ecx,[ebp+08]
...[00001288][002120b7][0000127e] 51         push ecx      // push P
...[00001289][002120b3][0000128e] e820feffff call 000010ae // call H
*Infinitely Recursive Simulation Detected Simulation Stopped*

H knows its own machine address and on this basis
H recognizes that P is calling H with its same arguments that it
was called with and there are no instructions preceding this call that
could possibly escape infinitely recursive emulation so H aborts its
emulation of P before P even makes its first call to H.

...[000012b0][0010201f][00000000] 83c408     add esp,+08
...[000012b3][0010201b][00000000] 50         push eax
...[000012b4][00102017][0000040f] 680f040000 push 0000040f
---[000012b9][00102017][0000040f] e8a0f1ffff call 0000045e
Input_Halts = 0
...[000012be][0010201f][00000000] 83c408     add esp,+08
...[000012c1][0010201f][00000000] 33c0       xor eax,eax
...[000012c3][00102023][00100000] 5d         pop ebp
...[000012c4][00102027][00000004] c3         ret
Number of Instructions Executed(1134) == 17 pages



Halting problem undecidability and infinitely nested simulation (V5)

https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5

All of the code including several halt deciders that use different
methods for pathological inputs and take 0,1,2 arguments, along with the complete x86 emulator fits in a 131K zip file and is configured as a
visual studio project. *I just got this done right now*

The prior pathological input decider required static local data that was stored directly in the function body. it construed infinitely nested simulation as infinite recursion.

The current pathological input decider is a pure function of its inputs.
The infinite loop and infinite recursion deciders remain the same.

This is the the design of the pathological input decider :

H knows its own machine address and on this basis:
(a) H recognizes that P is calling H with the same arguments that H was called with.
(b) There are no instructions in P that could possibly escape this
infinitely recursive emulation.
(c) H aborts its emulation of P before P its call to H is invoked.

The problem is your rule is incorrect, P doesn't need an instruction in
the code in P before the call to H to terminate the recurssion, because
the instruction to terminate the recursion exists in H,

If H aborts its simulation and returns the 0 to P, then P halts, and
thus H was wrong to decide its input was non-halting.

In all the cases, P is asking H to decide on what it will itself with
the input it was given, and it does the opposite.

The parameters given to H don't actually ask that question, then you
formed P incorrectly, so your "proof" is invalid.

If you CAN'T ask H that question, then H fails to even pretend to be a universal halt decider, not even being able to be asked the key question
that shows that a universal halt decider can't exist.

Thus, your proof doesn't actually show what you claim, because you are
using an incorrect criteria.

The ONLY valid criteria is will the computation represented by the input
Halt when run as an unfettered computation, and P (your name for H^)
makes sure that H doesn't give the right answer. Alternate criteria can
be used, but only if they exactly agree with the actual definition.
Since yours doesn't, you can't use it.

FAIL.

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