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, then for ANY halt decider H, H(P,P) returning 0 is the incorrect
answer for a Halting Decider.

DEFINITION.

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