My research seems to be the first time that anyone fully analyzed
applying a simulating halt decider (SHD) to the halting problem's
pathological inputs.

Prior to this no one was aware that when a halt decider correctly
simulates its input that the behavior of this simulated input could
possibly diverge from the behavior of the direct execution of this same
input. This only occurs when a pathological relationship exists between
a halt decider and its input.

When H(P,P) performs a correct x86 emulation of its input the behavior
of this emulated input is entirely different than the behavior of the
directly executed P(P). Until this is empirically validated by provably
correct execution traces this may seem to be impossible.

In fact all of my reviewers rejected the provably correct execution
traces in favor of their intuition. When we carefully examine the actual
facts (provided by the provably correct execution traces) we find that
this intuition is incorrect.

Since no one has ever fully examined applying a simulating halt decider
(SHD) to the Halting Problem's pathological inputs ever before no one
ever noticed that the behavior of a correctly simulated input would
diverge from the behavior of the directly executed input.

Because no one was previously aware of this divergence textbook authors
simply refer to the behavior of the directly executed input as the
criterion measure for a halt decider.

When we know that a halt decider must compute the mapping from its
inputs to an accept or reject state on the basis of the actual behavior
that is actually specified by these inputs then it becomes clear that
these textbook authors merely based their criterion measure on a false
assumption.

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

int main()
{ P(P);
}

_P()
[000012e7](01) 55 push ebp
[000012e8](02) 8bec mov ebp,esp
[000012ea](03) 8b4508 mov eax,[ebp+08]
[000012ed](01) 50 push eax
[000012ee](03) 8b4d08 mov ecx,[ebp+08]
[000012f1](01) 51 push ecx
[000012f2](05) e880feffff call 00001177 // call H
[000012f7](03) 83c408 add esp,+08
[000012fa](02) 85c0 test eax,eax
[000012fc](02) 7402 jz 00001300
[000012fe](02) ebfe jmp 000012fe
[00001300](01) 5d pop ebp
[00001301](01) c3 ret
Size in bytes:(0027) [00001301]
_main()
[00001307](01) 55 push ebp
[00001308](02) 8bec mov ebp,esp
[0000130a](05) 68e7120000 push 000012e7 // push P
[0000130f](05) e8d3ffffff call 000012e7 // call P
[00001314](03) 83c404 add esp,+04
[00001317](02) 33c0 xor eax,eax
[00001319](01) 5d pop ebp
[0000131a](01) c3 ret
Size in bytes:(0020) [0000131a]

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[00001307][00102190][00000000] 55 push ebp
[00001308][00102190][00000000] 8bec mov ebp,esp
[0000130a][0010218c][000012e7] 68e7120000 push 000012e7 // push P
[0000130f][00102188][00001314] e8d3ffffff call 000012e7 // call P
[000012e7][00102184][00102190] 55 push ebp // enter executed P
[000012e8][00102184][00102190] 8bec mov ebp,esp
[000012ea][00102184][00102190] 8b4508 mov eax,[ebp+08]
[000012ed][00102180][000012e7] 50 push eax // push P
[000012ee][00102180][000012e7] 8b4d08 mov ecx,[ebp+08]
[000012f1][0010217c][000012e7] 51 push ecx // push P
[000012f2][00102178][000012f7] e880feffff call 00001177 // call H

Begin Local Halt Decider Simulation Execution Trace Stored at:212244
[000012e7][00212230][00212234] 55 push ebp // enter emulated P
[000012e8][00212230][00212234] 8bec mov ebp,esp
[000012ea][00212230][00212234] 8b4508 mov eax,[ebp+08]
[000012ed][0021222c][000012e7] 50 push eax // push P
[000012ee][0021222c][000012e7] 8b4d08 mov ecx,[ebp+08]
[000012f1][00212228][000012e7] 51 push ecx // push P
[000012f2][00212224][000012f7] e880feffff call 00001177 // call H
[000012e7][0025cc58][0025cc5c] 55 push ebp // enter emulated P
[000012e8][0025cc58][0025cc5c] 8bec mov ebp,esp
[000012ea][0025cc58][0025cc5c] 8b4508 mov eax,[ebp+08]
[000012ed][0025cc54][000012e7] 50 push eax // push P
[000012ee][0025cc54][000012e7] 8b4d08 mov ecx,[ebp+08]
[000012f1][0025cc50][000012e7] 51 push ecx // push P
[000012f2][0025cc4c][000012f7] e880feffff call 00001177 // call H
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

It is completely obvious that when H(P,P) correctly emulates its input
that it must emulate the first seven instructions of P.

Because the seventh instruction of P repeats this process we know with
complete certainty that the correct and complete emulation of P by H
would never reach the final “ret” instruction of P, thus never halt.

[000012f7][00102184][00102190] 83c408 add esp,+08
[000012fa][00102184][00102190] 85c0 test eax,eax
[000012fc][00102184][00102190] 7402 jz 00001300
[00001300][00102188][00001314] 5d pop ebp
[00001301][0010218c][000012e7] c3 ret // executed P halts
[00001314][00102190][00000000] 83c404 add esp,+04
[00001317][00102190][00000000] 33c0 xor eax,eax
[00001319][00102194][00100000] 5d pop ebp
[0000131a][00102198][00000000] c3 ret // main() halts
Number of Instructions Executed(15900) 237 pages

When P(P) is executed its behavior depends on the return value of H.
When H(P,P) is executed the correctly emulated P cannot possibly reach
the point where its behavior depends on H. This makes the behavior of
P(P) diverge from the behavior of the input to H(P,P).

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

On 6/13/22 7:12 PM, olcott wrote:
> My research seems to be the first time that anyone fully analyzed
> applying a simulating halt decider (SHD) to the halting problem's
> pathological inputs.
>
> Prior to this no one was aware that when a halt decider correctly
> simulates its input that the behavior of this simulated input could
> possibly diverge from the behavior of the direct execution of this same
> input. This only occurs when a pathological relationship exists between
> a halt decider and its input.

Because it CAN'T

>
> When H(P,P) performs a correct x86 emulation of its input the behavior
> of this emulated input is entirely different than the behavior of the
> directly executed P(P). Until this is empirically validated by provably
> correct execution traces this may seem to be impossible.

Nope, just lies.

If you want to claim this difference, what is the first instruction of
the two that differs.

Until you answer that question, all you have are worthless claims shown
to be lies.

You are just living in a fantasy world where truth isn't actually truth.

>
> In fact all of my reviewers rejected the provably correct execution
> traces in favor of their intuition. When we carefully examine the actual
> facts (provided by the provably correct execution traces) we find that
> this intuition is incorrect.
>
> Since no one has ever fully examined applying a simulating halt decider
> (SHD) to the Halting Problem's pathological inputs ever before no one
> ever noticed that the behavior of a correctly simulated input would
> diverge from the behavior of the directly executed input.
>
> Because no one was previously aware of this divergence textbook authors
> simply refer to the behavior of the directly executed input as the
> criterion measure for a halt decider.
>
> When we know that a halt decider must compute the mapping from its
> inputs to an accept or reject state on the basis of the actual behavior
> that is actually specified by these inputs then it becomes clear that
> these textbook authors merely based their criterion measure on a false
> assumption.
>
>
> void P(u32 x)
> {
>   if (H(x, x))
>     HERE: goto HERE;
>   return;
> }
>
> int main()
> {
>   P(P);
> }
>
> _P()
> [000012e7](01)  55              push ebp
> [000012e8](02)  8bec            mov ebp,esp
> [000012ea](03)  8b4508          mov eax,[ebp+08]
> [000012ed](01)  50              push eax
> [000012ee](03)  8b4d08          mov ecx,[ebp+08]
> [000012f1](01)  51              push ecx
> [000012f2](05)  e880feffff      call 00001177 // call H
> [000012f7](03)  83c408          add esp,+08
> [000012fa](02)  85c0            test eax,eax
> [000012fc](02)  7402            jz 00001300
> [000012fe](02)  ebfe            jmp 000012fe
> [00001300](01)  5d              pop ebp
> [00001301](01)  c3              ret
> Size in bytes:(0027) [00001301]
> _main()
> [00001307](01)  55              push ebp
> [00001308](02)  8bec            mov ebp,esp
> [0000130a](05)  68e7120000      push 000012e7 // push P
> [0000130f](05)  e8d3ffffff      call 000012e7 // call P
> [00001314](03)  83c404          add esp,+04
> [00001317](02)  33c0            xor eax,eax
> [00001319](01)  5d              pop ebp
> [0000131a](01)  c3              ret
> Size in bytes:(0020) [0000131a]
>
>  machine   stack     stack     machine    assembly
>  address   address   data      code       language
>  ========  ========  ========  =========  =============
> [00001307][00102190][00000000] 55         push ebp
> [00001308][00102190][00000000] 8bec       mov ebp,esp
> [0000130a][0010218c][000012e7] 68e7120000 push 000012e7 // push P
> [0000130f][00102188][00001314] e8d3ffffff call 000012e7 // call P
> [000012e7][00102184][00102190] 55         push ebp      // enter executed P
> [000012e8][00102184][00102190] 8bec       mov ebp,esp
> [000012ea][00102184][00102190] 8b4508     mov eax,[ebp+08]
> [000012ed][00102180][000012e7] 50         push eax      // push P
> [000012ee][00102180][000012e7] 8b4d08     mov ecx,[ebp+08]
> [000012f1][0010217c][000012e7] 51         push ecx      // push P
> [000012f2][00102178][000012f7] e880feffff call 00001177 // call H
>
>
> Begin Local Halt Decider Simulation   Execution Trace Stored at:212244
> [000012e7][00212230][00212234] 55          push ebp      // enter
> emulated P
> [000012e8][00212230][00212234] 8bec        mov ebp,esp
> [000012ea][00212230][00212234] 8b4508      mov eax,[ebp+08]
> [000012ed][0021222c][000012e7] 50          push eax      // push P
> [000012ee][0021222c][000012e7] 8b4d08      mov ecx,[ebp+08]
> [000012f1][00212228][000012e7] 51          push ecx      // push P
> [000012f2][00212224][000012f7] e880feffff  call 00001177 // call H
> [000012e7][0025cc58][0025cc5c] 55          push ebp      // enter
> emulated P
> [000012e8][0025cc58][0025cc5c] 8bec        mov ebp,esp
> [000012ea][0025cc58][0025cc5c] 8b4508      mov eax,[ebp+08]
> [000012ed][0025cc54][000012e7] 50          push eax      // push P
> [000012ee][0025cc54][000012e7] 8b4d08      mov ecx,[ebp+08]
> [000012f1][0025cc50][000012e7] 51          push ecx      // push P
> [000012f2][0025cc4c][000012f7] e880feffff  call 00001177 // call H
> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>
> It is completely obvious that when H(P,P) correctly emulates its input
> that it must emulate the first seven instructions of P.
>
> Because the seventh instruction of P repeats this process we know with
> complete certainty that the correct and complete emulation of P by H
> would never reach the final “ret” instruction of P, thus never halt.
>
> [000012f7][00102184][00102190] 83c408      add esp,+08
> [000012fa][00102184][00102190] 85c0        test eax,eax
> [000012fc][00102184][00102190] 7402        jz 00001300
> [00001300][00102188][00001314] 5d          pop ebp
> [00001301][0010218c][000012e7] c3          ret           // executed P
> halts
> [00001314][00102190][00000000] 83c404      add esp,+04
> [00001317][00102190][00000000] 33c0        xor eax,eax
> [00001319][00102194][00100000] 5d          pop ebp
> [0000131a][00102198][00000000] c3          ret           // main() halts
> Number of Instructions Executed(15900) 237 pages
>
> When P(P) is executed its behavior depends on the return value of H.
> When H(P,P) is executed the correctly emulated P cannot possibly reach
> the point where its behavior depends on H. This makes the behavior of
> P(P) diverge from the behavior of the input to H(P,P).
>
>
>
> Halting problem undecidability and infinitely nested simulation (V5)
>
> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>
>

On Mon, 13 Jun 2022 18:12:49 -0500
olcott <NoOne@NoWhere.com> wrote:

> My research seems to be the first time that anyone fully analyzed
> applying a simulating halt decider (SHD) to the halting problem's
> pathological inputs.
>
> Prior to this no one was aware that when a halt decider correctly
> simulates its input that the behavior of this simulated input could
> possibly diverge from the behavior of the direct execution of this
> same input. This only occurs when a pathological relationship exists
> between a halt decider and its input.
>
> When H(P,P) performs a correct x86 emulation of its input the
> behavior of this emulated input is entirely different than the
> behavior of the directly executed P(P). Until this is empirically
> validated by provably correct execution traces this may seem to be
> impossible.
>
> In fact all of my reviewers rejected the provably correct execution
> traces in favor of their intuition. When we carefully examine the
> actual facts (provided by the provably correct execution traces) we
> find that this intuition is incorrect.
>
> Since no one has ever fully examined applying a simulating halt
> decider (SHD) to the Halting Problem's pathological inputs ever
> before no one ever noticed that the behavior of a correctly simulated
> input would diverge from the behavior of the directly executed input.
>
> Because no one was previously aware of this divergence textbook
> authors simply refer to the behavior of the directly executed input
> as the criterion measure for a halt decider.
>
> When we know that a halt decider must compute the mapping from its
> inputs to an accept or reject state on the basis of the actual
> behavior that is actually specified by these inputs then it becomes
> clear that these textbook authors merely based their criterion
> measure on a false assumption.
>
>
> void P(u32 x)
> {
> if (H(x, x))
> HERE: goto HERE;
> return;
> }
>
> int main()
> {
> P(P);
> }
>
> _P()
> [000012e7](01) 55 push ebp
> [000012e8](02) 8bec mov ebp,esp
> [000012ea](03) 8b4508 mov eax,[ebp+08]
> [000012ed](01) 50 push eax
> [000012ee](03) 8b4d08 mov ecx,[ebp+08]
> [000012f1](01) 51 push ecx
> [000012f2](05) e880feffff call 00001177 // call H
> [000012f7](03) 83c408 add esp,+08
> [000012fa](02) 85c0 test eax,eax
> [000012fc](02) 7402 jz 00001300
> [000012fe](02) ebfe jmp 000012fe
> [00001300](01) 5d pop ebp
> [00001301](01) c3 ret
> Size in bytes:(0027) [00001301]
> _main()
> [00001307](01) 55 push ebp
> [00001308](02) 8bec mov ebp,esp
> [0000130a](05) 68e7120000 push 000012e7 // push P
> [0000130f](05) e8d3ffffff call 000012e7 // call P
> [00001314](03) 83c404 add esp,+04
> [00001317](02) 33c0 xor eax,eax
> [00001319](01) 5d pop ebp
> [0000131a](01) c3 ret
> Size in bytes:(0020) [0000131a]
>
> machine stack stack machine assembly
> address address data code language
> ======== ======== ======== ========= ============> [00001307][00102190][00000000] 55 push ebp
> [00001308][00102190][00000000] 8bec mov ebp,esp
> [0000130a][0010218c][000012e7] 68e7120000 push 000012e7 // push P
> [0000130f][00102188][00001314] e8d3ffffff call 000012e7 // call P
> [000012e7][00102184][00102190] 55 push ebp // enter
> executed P [000012e8][00102184][00102190] 8bec mov ebp,esp
> [000012ea][00102184][00102190] 8b4508 mov eax,[ebp+08]
> [000012ed][00102180][000012e7] 50 push eax // push P
> [000012ee][00102180][000012e7] 8b4d08 mov ecx,[ebp+08]
> [000012f1][0010217c][000012e7] 51 push ecx // push P
> [000012f2][00102178][000012f7] e880feffff call 00001177 // call H
>
>
> Begin Local Halt Decider Simulation Execution Trace Stored at:212244
> [000012e7][00212230][00212234] 55 push ebp // enter
> emulated P [000012e8][00212230][00212234] 8bec mov ebp,esp
> [000012ea][00212230][00212234] 8b4508 mov eax,[ebp+08]
> [000012ed][0021222c][000012e7] 50 push eax // push P
> [000012ee][0021222c][000012e7] 8b4d08 mov ecx,[ebp+08]
> [000012f1][00212228][000012e7] 51 push ecx // push P
> [000012f2][00212224][000012f7] e880feffff call 00001177 // call H
> [000012e7][0025cc58][0025cc5c] 55 push ebp // enter
> emulated P [000012e8][0025cc58][0025cc5c] 8bec mov ebp,esp
> [000012ea][0025cc58][0025cc5c] 8b4508 mov eax,[ebp+08]
> [000012ed][0025cc54][000012e7] 50 push eax // push P
> [000012ee][0025cc54][000012e7] 8b4d08 mov ecx,[ebp+08]
> [000012f1][0025cc50][000012e7] 51 push ecx // push P
> [000012f2][0025cc4c][000012f7] e880feffff call 00001177 // call H
> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>
> It is completely obvious that when H(P,P) correctly emulates its
> input that it must emulate the first seven instructions of P.
>
> Because the seventh instruction of P repeats this process we know
> with complete certainty that the correct and complete emulation of P
> by H would never reach the final “ret” instruction of P, thus never
> halt.
>
> [000012f7][00102184][00102190] 83c408 add esp,+08
> [000012fa][00102184][00102190] 85c0 test eax,eax
> [000012fc][00102184][00102190] 7402 jz 00001300
> [00001300][00102188][00001314] 5d pop ebp
> [00001301][0010218c][000012e7] c3 ret // executed
> P halts [00001314][00102190][00000000] 83c404 add esp,+04
> [00001317][00102190][00000000] 33c0 xor eax,eax
> [00001319][00102194][00100000] 5d pop ebp
> [0000131a][00102198][00000000] c3 ret // main()
> halts Number of Instructions Executed(15900) 237 pages
>
> When P(P) is executed its behavior depends on the return value of H.
> When H(P,P) is executed the correctly emulated P cannot possibly
> reach the point where its behavior depends on H. This makes the
> behavior of P(P) diverge from the behavior of the input to H(P,P).
>
>
>
> Halting problem undecidability and infinitely nested simulation (V5)
>
> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5

You have yet to show that your H can detect all forms of infinite
cycle; all you have shown (if your traces are to be believed) is that
you can detect a single case of the most trivial form of cycle, the x86
opcodes "EB FE". You have also yet to show that your H can
correctly decide a halting P that non-pathologically calls H (i.e.
doesn't try to do the opposite of what H indicates).

Until you publish source code backing up your claims the evidence
simply isn't there that your H is a halt decider; all you have is an
olcott simulation detector: a pretty useless widget.

/Flibble

On 6/13/2022 6:33 PM, Mr Flibble wrote:
> On Mon, 13 Jun 2022 18:12:49 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> My research seems to be the first time that anyone fully analyzed
>> applying a simulating halt decider (SHD) to the halting problem's
>> pathological inputs.
>>
>> Prior to this no one was aware that when a halt decider correctly
>> simulates its input that the behavior of this simulated input could
>> possibly diverge from the behavior of the direct execution of this
>> same input. This only occurs when a pathological relationship exists
>> between a halt decider and its input.
>>
>> When H(P,P) performs a correct x86 emulation of its input the
>> behavior of this emulated input is entirely different than the
>> behavior of the directly executed P(P). Until this is empirically
>> validated by provably correct execution traces this may seem to be
>> impossible.
>>
>> In fact all of my reviewers rejected the provably correct execution
>> traces in favor of their intuition. When we carefully examine the
>> actual facts (provided by the provably correct execution traces) we
>> find that this intuition is incorrect.
>>
>> Since no one has ever fully examined applying a simulating halt
>> decider (SHD) to the Halting Problem's pathological inputs ever
>> before no one ever noticed that the behavior of a correctly simulated
>> input would diverge from the behavior of the directly executed input.
>>
>> Because no one was previously aware of this divergence textbook
>> authors simply refer to the behavior of the directly executed input
>> as the criterion measure for a halt decider.
>>
>> When we know that a halt decider must compute the mapping from its
>> inputs to an accept or reject state on the basis of the actual
>> behavior that is actually specified by these inputs then it becomes
>> clear that these textbook authors merely based their criterion
>> measure on a false assumption.
>>
>>
>> void P(u32 x)
>> {
>> if (H(x, x))
>> HERE: goto HERE;
>> return;
>> }
>>
>> int main()
>> {
>> P(P);
>> }
>>
>> _P()
>> [000012e7](01) 55 push ebp
>> [000012e8](02) 8bec mov ebp,esp
>> [000012ea](03) 8b4508 mov eax,[ebp+08]
>> [000012ed](01) 50 push eax
>> [000012ee](03) 8b4d08 mov ecx,[ebp+08]
>> [000012f1](01) 51 push ecx
>> [000012f2](05) e880feffff call 00001177 // call H
>> [000012f7](03) 83c408 add esp,+08
>> [000012fa](02) 85c0 test eax,eax
>> [000012fc](02) 7402 jz 00001300
>> [000012fe](02) ebfe jmp 000012fe
>> [00001300](01) 5d pop ebp
>> [00001301](01) c3 ret
>> Size in bytes:(0027) [00001301]
>> _main()
>> [00001307](01) 55 push ebp
>> [00001308](02) 8bec mov ebp,esp
>> [0000130a](05) 68e7120000 push 000012e7 // push P
>> [0000130f](05) e8d3ffffff call 000012e7 // call P
>> [00001314](03) 83c404 add esp,+04
>> [00001317](02) 33c0 xor eax,eax
>> [00001319](01) 5d pop ebp
>> [0000131a](01) c3 ret
>> Size in bytes:(0020) [0000131a]
>>
>> machine stack stack machine assembly
>> address address data code language
>> ======== ======== ======== ========= =============
>> [00001307][00102190][00000000] 55 push ebp
>> [00001308][00102190][00000000] 8bec mov ebp,esp
>> [0000130a][0010218c][000012e7] 68e7120000 push 000012e7 // push P
>> [0000130f][00102188][00001314] e8d3ffffff call 000012e7 // call P
>> [000012e7][00102184][00102190] 55 push ebp // enter
>> executed P [000012e8][00102184][00102190] 8bec mov ebp,esp
>> [000012ea][00102184][00102190] 8b4508 mov eax,[ebp+08]
>> [000012ed][00102180][000012e7] 50 push eax // push P
>> [000012ee][00102180][000012e7] 8b4d08 mov ecx,[ebp+08]
>> [000012f1][0010217c][000012e7] 51 push ecx // push P
>> [000012f2][00102178][000012f7] e880feffff call 00001177 // call H
>>
>>
>> Begin Local Halt Decider Simulation Execution Trace Stored at:212244
>> [000012e7][00212230][00212234] 55 push ebp // enter
>> emulated P [000012e8][00212230][00212234] 8bec mov ebp,esp
>> [000012ea][00212230][00212234] 8b4508 mov eax,[ebp+08]
>> [000012ed][0021222c][000012e7] 50 push eax // push P
>> [000012ee][0021222c][000012e7] 8b4d08 mov ecx,[ebp+08]
>> [000012f1][00212228][000012e7] 51 push ecx // push P
>> [000012f2][00212224][000012f7] e880feffff call 00001177 // call H
>> [000012e7][0025cc58][0025cc5c] 55 push ebp // enter
>> emulated P [000012e8][0025cc58][0025cc5c] 8bec mov ebp,esp
>> [000012ea][0025cc58][0025cc5c] 8b4508 mov eax,[ebp+08]
>> [000012ed][0025cc54][000012e7] 50 push eax // push P
>> [000012ee][0025cc54][000012e7] 8b4d08 mov ecx,[ebp+08]
>> [000012f1][0025cc50][000012e7] 51 push ecx // push P
>> [000012f2][0025cc4c][000012f7] e880feffff call 00001177 // call H
>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>
>> It is completely obvious that when H(P,P) correctly emulates its
>> input that it must emulate the first seven instructions of P.
>>
>> Because the seventh instruction of P repeats this process we know
>> with complete certainty that the correct and complete emulation of P
>> by H would never reach the final “ret” instruction of P, thus never
>> halt.
>>
>> [000012f7][00102184][00102190] 83c408 add esp,+08
>> [000012fa][00102184][00102190] 85c0 test eax,eax
>> [000012fc][00102184][00102190] 7402 jz 00001300
>> [00001300][00102188][00001314] 5d pop ebp
>> [00001301][0010218c][000012e7] c3 ret // executed
>> P halts [00001314][00102190][00000000] 83c404 add esp,+04
>> [00001317][00102190][00000000] 33c0 xor eax,eax
>> [00001319][00102194][00100000] 5d pop ebp
>> [0000131a][00102198][00000000] c3 ret // main()
>> halts Number of Instructions Executed(15900) 237 pages
>>
>> When P(P) is executed its behavior depends on the return value of H.
>> When H(P,P) is executed the correctly emulated P cannot possibly
>> reach the point where its behavior depends on H. This makes the
>> behavior of P(P) diverge from the behavior of the input to H(P,P).
>>
>>
>>
>> Halting problem undecidability and infinitely nested simulation (V5)
>>
>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>
> You have yet to show that your H can detect all forms of infinite
> cycle;

No I do not and after very many repeated corrections you seem to simply
lack the intellectual capacity to understand otherwise.

I can completely ignore all loops infinite or not all recursion infinite
or not and still prove that H(P,P) does correctly decide the halt status
of its input. The halt status of the input to H(P,P) is the entire
software engineering scope of my research.

If you are looking for a white dog in your living room you need not look
for anything else anywhere else.

> all you have shown (if your traces are to be believed) is that
> you can detect a single case of the most trivial form of cycle, the x86
> opcodes "EB FE". You have also yet to show that your H can
> correctly decide a halting P that non-pathologically calls H (i.e.
> doesn't try to do the opposite of what H indicates).
>
> Until you publish source code backing up your claims the evidence
> simply isn't there that your H is a halt decider; all you have is an
> olcott simulation detector: a pretty useless widget.
>
> /Flibble
>

--
Copyright 2022 Pete Olcott

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

On 6/13/22 7:40 PM, olcott wrote:
> On 6/13/2022 6:33 PM, Mr Flibble wrote:
>> On Mon, 13 Jun 2022 18:12:49 -0500
>> olcott <NoOne@NoWhere.com> wrote:
>>
>>> My research seems to be the first time that anyone fully analyzed
>>> applying a simulating halt decider (SHD) to the halting problem's
>>> pathological inputs.
>>>
>>> Prior to this no one was aware that when a halt decider correctly
>>> simulates its input that the behavior of this simulated input could
>>> possibly diverge from the behavior of the direct execution of this
>>> same input. This only occurs when a pathological relationship exists
>>> between a halt decider and its input.
>>>
>>> When H(P,P) performs a correct x86 emulation of its input the
>>> behavior of this emulated input is entirely different than the
>>> behavior of the directly executed P(P). Until this is empirically
>>> validated by provably correct execution traces this may seem to be
>>> impossible.
>>>
>>> In fact all of my reviewers rejected the provably correct execution
>>> traces in favor of their intuition. When we carefully examine the
>>> actual facts (provided by the provably correct execution traces) we
>>> find that this intuition is incorrect.
>>>
>>> Since no one has ever fully examined applying a simulating halt
>>> decider (SHD) to the Halting Problem's pathological inputs ever
>>> before no one ever noticed that the behavior of a correctly simulated
>>> input would diverge from the behavior of the directly executed input.
>>>
>>> Because no one was previously aware of this divergence textbook
>>> authors simply refer to the behavior of the directly executed input
>>> as the criterion measure for a halt decider.
>>>
>>> When we know that a halt decider must compute the mapping from its
>>> inputs to an accept or reject state on the basis of the actual
>>> behavior that is actually specified by these inputs then it becomes
>>> clear that these textbook authors merely based their criterion
>>> measure on a false assumption.
>>>
>>>
>>> void P(u32 x)
>>> {
>>>     if (H(x, x))
>>>       HERE: goto HERE;
>>>     return;
>>> }
>>>
>>> int main()
>>> {
>>>     P(P);
>>> }
>>>
>>> _P()
>>> [000012e7](01)  55              push ebp
>>> [000012e8](02)  8bec            mov ebp,esp
>>> [000012ea](03)  8b4508          mov eax,[ebp+08]
>>> [000012ed](01)  50              push eax
>>> [000012ee](03)  8b4d08          mov ecx,[ebp+08]
>>> [000012f1](01)  51              push ecx
>>> [000012f2](05)  e880feffff      call 00001177 // call H
>>> [000012f7](03)  83c408          add esp,+08
>>> [000012fa](02)  85c0            test eax,eax
>>> [000012fc](02)  7402            jz 00001300
>>> [000012fe](02)  ebfe            jmp 000012fe
>>> [00001300](01)  5d              pop ebp
>>> [00001301](01)  c3              ret
>>> Size in bytes:(0027) [00001301]
>>> _main()
>>> [00001307](01)  55              push ebp
>>> [00001308](02)  8bec            mov ebp,esp
>>> [0000130a](05)  68e7120000      push 000012e7 // push P
>>> [0000130f](05)  e8d3ffffff      call 000012e7 // call P
>>> [00001314](03)  83c404          add esp,+04
>>> [00001317](02)  33c0            xor eax,eax
>>> [00001319](01)  5d              pop ebp
>>> [0000131a](01)  c3              ret
>>> Size in bytes:(0020) [0000131a]
>>>
>>>    machine   stack     stack     machine    assembly
>>>    address   address   data      code       language
>>>    ========  ========  ========  =========  =============
>>> [00001307][00102190][00000000] 55         push ebp
>>> [00001308][00102190][00000000] 8bec       mov ebp,esp
>>> [0000130a][0010218c][000012e7] 68e7120000 push 000012e7 // push P
>>> [0000130f][00102188][00001314] e8d3ffffff call 000012e7 // call P
>>> [000012e7][00102184][00102190] 55         push ebp      // enter
>>> executed P [000012e8][00102184][00102190] 8bec       mov ebp,esp
>>> [000012ea][00102184][00102190] 8b4508     mov eax,[ebp+08]
>>> [000012ed][00102180][000012e7] 50         push eax      // push P
>>> [000012ee][00102180][000012e7] 8b4d08     mov ecx,[ebp+08]
>>> [000012f1][0010217c][000012e7] 51         push ecx      // push P
>>> [000012f2][00102178][000012f7] e880feffff call 00001177 // call H
>>>
>>>
>>> Begin Local Halt Decider Simulation   Execution Trace Stored at:212244
>>> [000012e7][00212230][00212234] 55          push ebp      // enter
>>> emulated P [000012e8][00212230][00212234] 8bec        mov ebp,esp
>>> [000012ea][00212230][00212234] 8b4508      mov eax,[ebp+08]
>>> [000012ed][0021222c][000012e7] 50          push eax      // push P
>>> [000012ee][0021222c][000012e7] 8b4d08      mov ecx,[ebp+08]
>>> [000012f1][00212228][000012e7] 51          push ecx      // push P
>>> [000012f2][00212224][000012f7] e880feffff  call 00001177 // call H
>>> [000012e7][0025cc58][0025cc5c] 55          push ebp      // enter
>>> emulated P [000012e8][0025cc58][0025cc5c] 8bec        mov ebp,esp
>>> [000012ea][0025cc58][0025cc5c] 8b4508      mov eax,[ebp+08]
>>> [000012ed][0025cc54][000012e7] 50          push eax      // push P
>>> [000012ee][0025cc54][000012e7] 8b4d08      mov ecx,[ebp+08]
>>> [000012f1][0025cc50][000012e7] 51          push ecx      // push P
>>> [000012f2][0025cc4c][000012f7] e880feffff  call 00001177 // call H
>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>>
>>> It is completely obvious that when H(P,P) correctly emulates its
>>> input that it must emulate the first seven instructions of P.
>>>
>>> Because the seventh instruction of P repeats this process we know
>>> with complete certainty that the correct and complete emulation of P
>>> by H would never reach the final “ret” instruction of P, thus never
>>> halt.
>>>
>>> [000012f7][00102184][00102190] 83c408      add esp,+08
>>> [000012fa][00102184][00102190] 85c0        test eax,eax
>>> [000012fc][00102184][00102190] 7402        jz 00001300
>>> [00001300][00102188][00001314] 5d          pop ebp
>>> [00001301][0010218c][000012e7] c3          ret           // executed
>>> P halts [00001314][00102190][00000000] 83c404      add esp,+04
>>> [00001317][00102190][00000000] 33c0        xor eax,eax
>>> [00001319][00102194][00100000] 5d          pop ebp
>>> [0000131a][00102198][00000000] c3          ret           // main()
>>> halts Number of Instructions Executed(15900) 237 pages
>>>
>>> When P(P) is executed its behavior depends on the return value of H.
>>> When H(P,P) is executed the correctly emulated P cannot possibly
>>> reach the point where its behavior depends on H. This makes the
>>> behavior of P(P) diverge from the behavior of the input to H(P,P).
>>>
>>>
>>>
>>> Halting problem undecidability and infinitely nested simulation (V5)
>>>
>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>>
>>
>> You have yet to show that your H can detect all forms of infinite
>> cycle;
>
> No I do not and after very many repeated corrections you seem to simply
> lack the intellectual capacity to understand otherwise.
>
> I can completely ignore all loops infinite or not all recursion infinite
> or not and still prove that H(P,P) does correctly decide the halt status
> of its input. The halt status of the input to H(P,P) is the entire
> software engineering scope of my research.
>
> If you are looking for a white dog in your living room you need not look
> for anything else anywhere else.

On 6/13/2022 7:09 PM, Richard Damon wrote:
> On 6/13/22 7:40 PM, olcott wrote:
>> On 6/13/2022 6:33 PM, Mr Flibble wrote:
>>> On Mon, 13 Jun 2022 18:12:49 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> My research seems to be the first time that anyone fully analyzed
>>>> applying a simulating halt decider (SHD) to the halting problem's
>>>> pathological inputs.
>>>>
>>>> Prior to this no one was aware that when a halt decider correctly
>>>> simulates its input that the behavior of this simulated input could
>>>> possibly diverge from the behavior of the direct execution of this
>>>> same input. This only occurs when a pathological relationship exists
>>>> between a halt decider and its input.
>>>>
>>>> When H(P,P) performs a correct x86 emulation of its input the
>>>> behavior of this emulated input is entirely different than the
>>>> behavior of the directly executed P(P). Until this is empirically
>>>> validated by provably correct execution traces this may seem to be
>>>> impossible.
>>>>
>>>> In fact all of my reviewers rejected the provably correct execution
>>>> traces in favor of their intuition. When we carefully examine the
>>>> actual facts (provided by the provably correct execution traces) we
>>>> find that this intuition is incorrect.
>>>>
>>>> Since no one has ever fully examined applying a simulating halt
>>>> decider (SHD) to the Halting Problem's pathological inputs ever
>>>> before no one ever noticed that the behavior of a correctly simulated
>>>> input would diverge from the behavior of the directly executed input.
>>>>
>>>> Because no one was previously aware of this divergence textbook
>>>> authors simply refer to the behavior of the directly executed input
>>>> as the criterion measure for a halt decider.
>>>>
>>>> When we know that a halt decider must compute the mapping from its
>>>> inputs to an accept or reject state on the basis of the actual
>>>> behavior that is actually specified by these inputs then it becomes
>>>> clear that these textbook authors merely based their criterion
>>>> measure on a false assumption.
>>>>
>>>>
>>>> void P(u32 x)
>>>> {
>>>>     if (H(x, x))
>>>>       HERE: goto HERE;
>>>>     return;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>>     P(P);
>>>> }
>>>>
>>>> _P()
>>>> [000012e7](01)  55              push ebp
>>>> [000012e8](02)  8bec            mov ebp,esp
>>>> [000012ea](03)  8b4508          mov eax,[ebp+08]
>>>> [000012ed](01)  50              push eax
>>>> [000012ee](03)  8b4d08          mov ecx,[ebp+08]
>>>> [000012f1](01)  51              push ecx
>>>> [000012f2](05)  e880feffff      call 00001177 // call H
>>>> [000012f7](03)  83c408          add esp,+08
>>>> [000012fa](02)  85c0            test eax,eax
>>>> [000012fc](02)  7402            jz 00001300
>>>> [000012fe](02)  ebfe            jmp 000012fe
>>>> [00001300](01)  5d              pop ebp
>>>> [00001301](01)  c3              ret
>>>> Size in bytes:(0027) [00001301]
>>>> _main()
>>>> [00001307](01)  55              push ebp
>>>> [00001308](02)  8bec            mov ebp,esp
>>>> [0000130a](05)  68e7120000      push 000012e7 // push P
>>>> [0000130f](05)  e8d3ffffff      call 000012e7 // call P
>>>> [00001314](03)  83c404          add esp,+04
>>>> [00001317](02)  33c0            xor eax,eax
>>>> [00001319](01)  5d              pop ebp
>>>> [0000131a](01)  c3              ret
>>>> Size in bytes:(0020) [0000131a]
>>>>
>>>>    machine   stack     stack     machine    assembly
>>>>    address   address   data      code       language
>>>>    ========  ========  ========  =========  =============
>>>> [00001307][00102190][00000000] 55         push ebp
>>>> [00001308][00102190][00000000] 8bec       mov ebp,esp
>>>> [0000130a][0010218c][000012e7] 68e7120000 push 000012e7 // push P
>>>> [0000130f][00102188][00001314] e8d3ffffff call 000012e7 // call P
>>>> [000012e7][00102184][00102190] 55         push ebp      // enter
>>>> executed P [000012e8][00102184][00102190] 8bec       mov ebp,esp
>>>> [000012ea][00102184][00102190] 8b4508     mov eax,[ebp+08]
>>>> [000012ed][00102180][000012e7] 50         push eax      // push P
>>>> [000012ee][00102180][000012e7] 8b4d08     mov ecx,[ebp+08]
>>>> [000012f1][0010217c][000012e7] 51         push ecx      // push P
>>>> [000012f2][00102178][000012f7] e880feffff call 00001177 // call H
>>>>
>>>>
>>>> Begin Local Halt Decider Simulation   Execution Trace Stored at:212244
>>>> [000012e7][00212230][00212234] 55          push ebp      // enter
>>>> emulated P [000012e8][00212230][00212234] 8bec        mov ebp,esp
>>>> [000012ea][00212230][00212234] 8b4508      mov eax,[ebp+08]
>>>> [000012ed][0021222c][000012e7] 50          push eax      // push P
>>>> [000012ee][0021222c][000012e7] 8b4d08      mov ecx,[ebp+08]
>>>> [000012f1][00212228][000012e7] 51          push ecx      // push P
>>>> [000012f2][00212224][000012f7] e880feffff  call 00001177 // call H
>>>> [000012e7][0025cc58][0025cc5c] 55          push ebp      // enter
>>>> emulated P [000012e8][0025cc58][0025cc5c] 8bec        mov ebp,esp
>>>> [000012ea][0025cc58][0025cc5c] 8b4508      mov eax,[ebp+08]
>>>> [000012ed][0025cc54][000012e7] 50          push eax      // push P
>>>> [000012ee][0025cc54][000012e7] 8b4d08      mov ecx,[ebp+08]
>>>> [000012f1][0025cc50][000012e7] 51          push ecx      // push P
>>>> [000012f2][0025cc4c][000012f7] e880feffff  call 00001177 // call H
>>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>>>
>>>> It is completely obvious that when H(P,P) correctly emulates its
>>>> input that it must emulate the first seven instructions of P.
>>>>
>>>> Because the seventh instruction of P repeats this process we know
>>>> with complete certainty that the correct and complete emulation of P
>>>> by H would never reach the final “ret” instruction of P, thus never
>>>> halt.
>>>>
>>>> [000012f7][00102184][00102190] 83c408      add esp,+08
>>>> [000012fa][00102184][00102190] 85c0        test eax,eax
>>>> [000012fc][00102184][00102190] 7402        jz 00001300
>>>> [00001300][00102188][00001314] 5d          pop ebp
>>>> [00001301][0010218c][000012e7] c3          ret           // executed
>>>> P halts [00001314][00102190][00000000] 83c404      add esp,+04
>>>> [00001317][00102190][00000000] 33c0        xor eax,eax
>>>> [00001319][00102194][00100000] 5d          pop ebp
>>>> [0000131a][00102198][00000000] c3          ret           // main()
>>>> halts Number of Instructions Executed(15900) 237 pages
>>>>
>>>> When P(P) is executed its behavior depends on the return value of H.
>>>> When H(P,P) is executed the correctly emulated P cannot possibly
>>>> reach the point where its behavior depends on H. This makes the
>>>> behavior of P(P) diverge from the behavior of the input to H(P,P).
>>>>
>>>>
>>>>
>>>> Halting problem undecidability and infinitely nested simulation (V5)
>>>>
>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>>>
>>>
>>> You have yet to show that your H can detect all forms of infinite
>>> cycle;
>>
>> No I do not and after very many repeated corrections you seem to
>> simply lack the intellectual capacity to understand otherwise.
>>
>> I can completely ignore all loops infinite or not all recursion
>> infinite or not and still prove that H(P,P) does correctly decide the
>> halt status of its input. The halt status of the input to H(P,P) is
>> the entire software engineering scope of my research.
>>
>> If you are looking for a white dog in your living room you need not
>> look for anything else anywhere else.
>
> And, since P(P) Halts when for the H that it is built on H(P,P) returns
> 0,

On 6/13/22 8:23 PM, olcott wrote:
> On 6/13/2022 7:09 PM, Richard Damon wrote:
>> On 6/13/22 7:40 PM, olcott wrote:
>>> On 6/13/2022 6:33 PM, Mr Flibble wrote:
>>>> On Mon, 13 Jun 2022 18:12:49 -0500
>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>
>>>>> My research seems to be the first time that anyone fully analyzed
>>>>> applying a simulating halt decider (SHD) to the halting problem's
>>>>> pathological inputs.
>>>>>
>>>>> Prior to this no one was aware that when a halt decider correctly
>>>>> simulates its input that the behavior of this simulated input could
>>>>> possibly diverge from the behavior of the direct execution of this
>>>>> same input. This only occurs when a pathological relationship exists
>>>>> between a halt decider and its input.
>>>>>
>>>>> When H(P,P) performs a correct x86 emulation of its input the
>>>>> behavior of this emulated input is entirely different than the
>>>>> behavior of the directly executed P(P). Until this is empirically
>>>>> validated by provably correct execution traces this may seem to be
>>>>> impossible.
>>>>>
>>>>> In fact all of my reviewers rejected the provably correct execution
>>>>> traces in favor of their intuition. When we carefully examine the
>>>>> actual facts (provided by the provably correct execution traces) we
>>>>> find that this intuition is incorrect.
>>>>>
>>>>> Since no one has ever fully examined applying a simulating halt
>>>>> decider (SHD) to the Halting Problem's pathological inputs ever
>>>>> before no one ever noticed that the behavior of a correctly simulated
>>>>> input would diverge from the behavior of the directly executed input.
>>>>>
>>>>> Because no one was previously aware of this divergence textbook
>>>>> authors simply refer to the behavior of the directly executed input
>>>>> as the criterion measure for a halt decider.
>>>>>
>>>>> When we know that a halt decider must compute the mapping from its
>>>>> inputs to an accept or reject state on the basis of the actual
>>>>> behavior that is actually specified by these inputs then it becomes
>>>>> clear that these textbook authors merely based their criterion
>>>>> measure on a false assumption.
>>>>>
>>>>>
>>>>> void P(u32 x)
>>>>> {
>>>>>     if (H(x, x))
>>>>>       HERE: goto HERE;
>>>>>     return;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>>     P(P);
>>>>> }
>>>>>
>>>>> _P()
>>>>> [000012e7](01)  55              push ebp
>>>>> [000012e8](02)  8bec            mov ebp,esp
>>>>> [000012ea](03)  8b4508          mov eax,[ebp+08]
>>>>> [000012ed](01)  50              push eax
>>>>> [000012ee](03)  8b4d08          mov ecx,[ebp+08]
>>>>> [000012f1](01)  51              push ecx
>>>>> [000012f2](05)  e880feffff      call 00001177 // call H
>>>>> [000012f7](03)  83c408          add esp,+08
>>>>> [000012fa](02)  85c0            test eax,eax
>>>>> [000012fc](02)  7402            jz 00001300
>>>>> [000012fe](02)  ebfe            jmp 000012fe
>>>>> [00001300](01)  5d              pop ebp
>>>>> [00001301](01)  c3              ret
>>>>> Size in bytes:(0027) [00001301]
>>>>> _main()
>>>>> [00001307](01)  55              push ebp
>>>>> [00001308](02)  8bec            mov ebp,esp
>>>>> [0000130a](05)  68e7120000      push 000012e7 // push P
>>>>> [0000130f](05)  e8d3ffffff      call 000012e7 // call P
>>>>> [00001314](03)  83c404          add esp,+04
>>>>> [00001317](02)  33c0            xor eax,eax
>>>>> [00001319](01)  5d              pop ebp
>>>>> [0000131a](01)  c3              ret
>>>>> Size in bytes:(0020) [0000131a]
>>>>>
>>>>>    machine   stack     stack     machine    assembly
>>>>>    address   address   data      code       language
>>>>>    ========  ========  ========  =========  =============
>>>>> [00001307][00102190][00000000] 55         push ebp
>>>>> [00001308][00102190][00000000] 8bec       mov ebp,esp
>>>>> [0000130a][0010218c][000012e7] 68e7120000 push 000012e7 // push P
>>>>> [0000130f][00102188][00001314] e8d3ffffff call 000012e7 // call P
>>>>> [000012e7][00102184][00102190] 55         push ebp      // enter
>>>>> executed P [000012e8][00102184][00102190] 8bec       mov ebp,esp
>>>>> [000012ea][00102184][00102190] 8b4508     mov eax,[ebp+08]
>>>>> [000012ed][00102180][000012e7] 50         push eax      // push P
>>>>> [000012ee][00102180][000012e7] 8b4d08     mov ecx,[ebp+08]
>>>>> [000012f1][0010217c][000012e7] 51         push ecx      // push P
>>>>> [000012f2][00102178][000012f7] e880feffff call 00001177 // call H
>>>>>
>>>>>
>>>>> Begin Local Halt Decider Simulation   Execution Trace Stored at:212244
>>>>> [000012e7][00212230][00212234] 55          push ebp      // enter
>>>>> emulated P [000012e8][00212230][00212234] 8bec        mov ebp,esp
>>>>> [000012ea][00212230][00212234] 8b4508      mov eax,[ebp+08]
>>>>> [000012ed][0021222c][000012e7] 50          push eax      // push P
>>>>> [000012ee][0021222c][000012e7] 8b4d08      mov ecx,[ebp+08]
>>>>> [000012f1][00212228][000012e7] 51          push ecx      // push P
>>>>> [000012f2][00212224][000012f7] e880feffff  call 00001177 // call H
>>>>> [000012e7][0025cc58][0025cc5c] 55          push ebp      // enter
>>>>> emulated P [000012e8][0025cc58][0025cc5c] 8bec        mov ebp,esp
>>>>> [000012ea][0025cc58][0025cc5c] 8b4508      mov eax,[ebp+08]
>>>>> [000012ed][0025cc54][000012e7] 50          push eax      // push P
>>>>> [000012ee][0025cc54][000012e7] 8b4d08      mov ecx,[ebp+08]
>>>>> [000012f1][0025cc50][000012e7] 51          push ecx      // push P
>>>>> [000012f2][0025cc4c][000012f7] e880feffff  call 00001177 // call H
>>>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>>>>
>>>>> It is completely obvious that when H(P,P) correctly emulates its
>>>>> input that it must emulate the first seven instructions of P.
>>>>>
>>>>> Because the seventh instruction of P repeats this process we know
>>>>> with complete certainty that the correct and complete emulation of P
>>>>> by H would never reach the final “ret” instruction of P, thus never
>>>>> halt.
>>>>>
>>>>> [000012f7][00102184][00102190] 83c408      add esp,+08
>>>>> [000012fa][00102184][00102190] 85c0        test eax,eax
>>>>> [000012fc][00102184][00102190] 7402        jz 00001300
>>>>> [00001300][00102188][00001314] 5d          pop ebp
>>>>> [00001301][0010218c][000012e7] c3          ret           // executed
>>>>> P halts [00001314][00102190][00000000] 83c404      add esp,+04
>>>>> [00001317][00102190][00000000] 33c0        xor eax,eax
>>>>> [00001319][00102194][00100000] 5d          pop ebp
>>>>> [0000131a][00102198][00000000] c3          ret           // main()
>>>>> halts Number of Instructions Executed(15900) 237 pages
>>>>>
>>>>> When P(P) is executed its behavior depends on the return value of H.
>>>>> When H(P,P) is executed the correctly emulated P cannot possibly
>>>>> reach the point where its behavior depends on H. This makes the
>>>>> behavior of P(P) diverge from the behavior of the input to H(P,P).
>>>>>
>>>>>
>>>>>
>>>>> Halting problem undecidability and infinitely nested simulation (V5)
>>>>>
>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>>>>
>>>>
>>>> You have yet to show that your H can detect all forms of infinite
>>>> cycle;
>>>
>>> No I do not and after very many repeated corrections you seem to
>>> simply lack the intellectual capacity to understand otherwise.
>>>
>>> I can completely ignore all loops infinite or not all recursion
>>> infinite or not and still prove that H(P,P) does correctly decide the
>>> halt status of its input. The halt status of the input to H(P,P) is
>>> the entire software engineering scope of my research.
>>>
>>> If you are looking for a white dog in your living room you need not
>>> look for anything else anywhere else.
>>
>> And, since P(P) Halts when for the H that it is built on H(P,P)
>> returns 0,
>
> That you continue to believe that an aborted simulated input continues
> to execute after it has been aborted is psychotic.
>
>