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.

0000135d is only unreachable if H never returns.

If H never returns, then if fails to be a decider, and thus can't be a
halt decider.

You need to get you definition of H straight, and until you do, you
can't make your arguement.

Either H does abort its simulation of it input of P,P, and return 0 and
thus P(P) is halting because that code is reached, or

H doesn't abort but just emulates as you othertimes claim, and this does
make P(P) non-halting, but it also make H(P,P) non-answering and thus H
is not a decider.

Your argument fails because you try to make be both options be true at
the same time but they are mutually exclusive of each other. You have
created a Liar's paradox, and are claiming that it is simultaniously
True and False and thus resolved.

You H is just not an actually definite function.

>
> https://en.wikipedia.org/wiki/Unreachable_code
>
> _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.

The 7th instruction doesn't just repeat the process, unless H is defined
to be an unconditional execution of its input.

Since that is NOT your definition of H, that is a false statement, so
your logic is UNSOUND.

>
> People that are not dumber than a box of rocks will understand this to
> mean that the correct x86 emulation of the input to H(P,P) by H cannot
> possibly reach any instruction after [0000135d].
>

The correct x86 emulation of the input to H(P,P) will reach the final
ret instruction if H(P,P) returns 0, because it aborted its simulation
of its input (and thus doesn't meet the defintion of a 'correct' emulation).

If H DOES do a correct and complete emulation of its input, then it
never answers for H(P,P) so fails to be the decider it is claimed to be.

You are just caught in assuming something that isn't true, because you
claim to sides of a contradiction are both true.