On 6/9/22 7:14 PM, olcott wrote:
> On 6/9/2022 6:09 PM, Richard Damon wrote:
>> On 6/9/22 6:37 PM, olcott wrote:
>>> On 6/9/2022 5:33 PM, Richard Damon wrote:
>>>> On 6/9/22 6:18 PM, olcott wrote:
>>>>> On 6/9/2022 5:15 PM, Mr Flibble wrote:
>>>>>> On Thu, 9 Jun 2022 17:09:08 -0500
>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>
>>>>>>> On 6/9/2022 4:54 PM, Richard Damon wrote:
>>>>>>>> On 6/9/22 5:29 PM, olcott wrote:
>>>>>>>>> On 6/9/2022 4:13 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 6/9/22 5:00 PM, olcott wrote:
>>>>>>>>>>> On 6/9/2022 3:25 PM, Richard Damon wrote:
>>>>>>>>>>>> On 6/9/22 4:13 PM, olcott wrote:
>>>>>>>>>>>>> On 6/9/2022 2:57 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 6/9/22 3:52 PM, olcott wrote:
>>>>>>>>>>>>>>> On 6/9/2022 2:38 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 6/9/22 3:26 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 6/9/2022 1:12 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 6/9/22 1:55 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 6/9/2022 12:46 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 12:39:32 -0500
>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 12:28 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 12:15:24 -0500
>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 12:06 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 12:54 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 11:34 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 11:47 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> 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
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> So, by what instruction reference manual is a
>>>>>>>>>>>>>>>>>>>>>>>>>> call 00001177
>>>>>>>>>>>>>>>>>>>>>>>>>> followedby the execution of the instruction at
>>>>>>>>>>>>>>>>>>>>>>>>>> 000012e7.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Your "CPU" is broken, or emulation incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>> [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 its final
>>>>>>>>>>>>>>>>>>>>>>>>>>> “ret” instruction, thus never halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Problem, the 7th intruction DOESN't "Just repeat
>>>>>>>>>>>>>>>>>>>>>>>>>> the procedure",
>>>>>>>>>>>>>>>>>>>>>>>>>> because that H always has the option to abort its
>>>>>>>>>>>>>>>>>>>>>>>>>> simulation,
>>>>>>>>>>>>>>>>>>>>>>>>>> just like this onne did, and return to its P and
>>>>>>>>>>>>>>>>>>>>>>>>>> see it halt.
>>>>>>>>>>>>>>>>>>>>>>>>> THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS
>>>>>>>>>>>>>>>>>>>>>>>>> IS NO ACTUAL
>>>>>>>>>>>>>>>>>>>>>>>>> REBUTTAL AT ALL:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> The partial correct x86 emulation of the input to
>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) conclusively proves that the complete and
>>>>>>>>>>>>>>>>>>>>>>>>> correct x86 emulation
>>>>>>>>>>>>>>>>>>>>>>>>> would never stop running.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> You SAY that, but you don't answer the actual
>>>>>>>>>>>>>>>>>>>>>>>> questions about HOW.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS
>>>>>>>>>>>>>>>>>>>>>>> NO EVIDENCE
>>>>>>>>>>>>>>>>>>>>>>> WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE THAT
>>>>>>>>>>>>>>>>>>>>>>> THE CORRECT
>>>>>>>>>>>>>>>>>>>>>>> PARTIAL EMULATION OF THE INPUT TO H(P,P)
>>>>>>>>>>>>>>>>>>>>>>> CONCLUSIVELY PROVES THAT
>>>>>>>>>>>>>>>>>>>>>>> THE CORRECT AND COMPLETE X86 EMULATION OF THE INPUT
>>>>>>>>>>>>>>>>>>>>>>> TO H(P,P)
>>>>>>>>>>>>>>>>>>>>>>> WOULD NEVER STOP RUNNING.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> 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 its final “ret”
>>>>>>>>>>>>>>>>>>>>>>> instruction, thus never
>>>>>>>>>>>>>>>>>>>>>>> halts.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> If P should have halted (i.e. no infinite loop) then
>>>>>>>>>>>>>>>>>>>>>> your simulation
>>>>>>>>>>>>>>>>>>>>>> detector, S (not H), gets the answer wrong.  You S is
>>>>>>>>>>>>>>>>>>>>>> NOT a halting
>>>>>>>>>>>>>>>>>>>>>> decider.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS
>>>>>>>>>>>>>>>>>>>>> NO ACTUAL
>>>>>>>>>>>>>>>>>>>>> REBUTTAL AT ALL.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> _P()
>>>>>>>>>>>>>>>>>>>>> [00001352](01)  55              push ebp
>>>>>>>>>>>>>>>>>>>>> [00001353](02)  8bec            mov ebp,esp
>>>>>>>>>>>>>>>>>>>>> [00001355](03)  8b4508          mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>> [00001358](01)  50              push eax      //
>>>>>>>>>>>>>>>>>>>>> push P
>>>>>>>>>>>>>>>>>>>>> [00001359](03)  8b4d08          mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>>>>>> [0000135c](01)  51              push ecx      //
>>>>>>>>>>>>>>>>>>>>> push P
>>>>>>>>>>>>>>>>>>>>> [0000135d](05)  e840feffff      call 000011a2 //
>>>>>>>>>>>>>>>>>>>>> call H
>>>>>>>>>>>>>>>>>>>>> [00001362](03)  83c408          add esp,+08
>>>>>>>>>>>>>>>>>>>>> [00001365](02)  85c0            test eax,eax
>>>>>>>>>>>>>>>>>>>>> [00001367](02)  7402            jz 0000136b
>>>>>>>>>>>>>>>>>>>>> [00001369](02)  ebfe            jmp 00001369
>>>>>>>>>>>>>>>>>>>>> [0000136b](01)  5d              pop ebp
>>>>>>>>>>>>>>>>>>>>> [0000136c](01)  c3              ret
>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> 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 its final “ret” instruction, thus
>>>>>>>>>>>>>>>>>>>>> never halts.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> We are going around and around and around in circles. I
>>>>>>>>>>>>>>>>>>>> will try again:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> If you replace the opcodes "EB FE" at 00001369 with the
>>>>>>>>>>>>>>>>>>>> opcodes "90 90"
>>>>>>>>>>>>>>>>>>>> then your H gets the answer wrong: P should have
>>>>>>>>>>>>>>>>>>>> halted.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> As I already said before this is merely your
>>>>>>>>>>>>>>>>>>> cluelessness that when H(P,P) is invoked the correct x86
>>>>>>>>>>>>>>>>>>> emulation of the input to H(P,P) makes and code after
>>>>>>>>>>>>>>>>>>> [0000135d] unreachable.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Wrong, because when that H return the value 0, it will
>>>>>>>>>>>>>>>>>> get there.
>>>>>>>>>>>>>>>>> Like I said people that are dumber than a box of rocks
>>>>>>>>>>>>>>>>> won't be able to correctly understand this.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> When H(P,P) is invoked the correctly emulated input to
>>>>>>>>>>>>>>>>> H(P,P) cannot possibly reach any instruction beyond
>>>>>>>>>>>>>>>>> [0000135d].
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> So, you are defining that you H(P,P) never returns because
>>>>>>>>>>>>>>>> it is caught in the infinite rcursion.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Thats fine, just says it can't be the correctly answering
>>>>>>>>>>>>>>>> decider you claim it to be.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I have corrected you on this too many times.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> How. You need to define what H(P,P) actually does.
>>>>>>>>>>>>>
>>>>>>>>>>>>> I have explained that too many times.
>>>>>>>>>>>>>
>>>>>>>>>>>>> To understand that H(P,P)==0 is correct we only need to know
>>>>>>>>>>>>> that H performs a correct x86 emulation of its input and then
>>>>>>>>>>>>> examine the execution trace.
>>>>>>>>>>>>
>>>>>>>>>>>> And a CORRECT emulation of the code will Halt if H(P,P) returns
>>>>>>>>>>>> 0, which it can only do if it does not actually do a correct
>>>>>>>>>>>> emulation
>>>>>>>>>>>
>>>>>>>>>>> The correctly emulated input to H(P,P) never gets past its
>>>>>>>>>>> machine address [0000135d].
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Only if H actually doesn't return 0. Yes, H can't correctly
>>>>>>>>>> return 0 if it correctly emulates its input, but you can't drop
>>>>>>>>>> that requirement.
>>>>>>>>>
>>>>>>>>> void P(u32 x)
>>>>>>>>> {
>>>>>>>>>     if (H(x, x))
>>>>>>>>>       HERE: goto HERE;
>>>>>>>>>     return;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> int main()
>>>>>>>>> {
>>>>>>>>>     Output("Input_Halts = ", H((u32)P, (u32)P));
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> When H returns 0 it does not returns 0 to P it returns 0 to
>>>>>>>>> main().
>>>>>>>>
>>>>>>>> But it also return 0 to the computation P(P), maybe not the copy
>>>>>>>> that it is simulating, since it aborts that before it get to it,
>>>>>>>
>>>>>>> Finally you are not stupid or deceptive.
>>>>>>
>>>>>> If H never returns a value to P then H is not a halting decider; if H
>>>>>> returns a value of 0 to main() when P halts then H is not a halting
>>>>>> decider.
>>>>>>
>>>>>> H is not a halting decider; H is a simulation detector, S.
>>>>>>
>>>>>> /Flibble
>>>>>>
>>>>>
>>>>> In other words you are saying the infintely nested emulation only
>>>>> excutes for a few steps and then it stops on its own.
>>>>>
>>>>
>>>> No, the "infinitely nested emulation" halts when the first H(P,P)
>>>> that P(P) called aborts it simulation.
>>>
>>> When I tell you that an input only halts when it reaches its final
>>> state and I tell you this many hundreds of times because you are a
>>> God damned liar you pretend that I never said this.
>>>
>>
>> Right, and when H(P,P) returns 0, the P that called it reaches its
>> final state/the ret instrucion.
>
> YOU GOD DAMNED LIAR main() calls H(P,P) and H returns to main()
>
> void P(u32 x)
> {
>   if (H(x, x))
>     HERE: goto HERE;
>   return;
> }
>
> int main()
> {
>   Output("Input_Halts = ", H((u32)P, (u32)P));
> }
>
>

Right, and P calls H which returns the 0 to P and P halts.

If you deny the existance of the program P, then you invalidate your
whole proof.