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.

You can state a requirement that make this true several ways, but
ultimately, you need something that constrains the behavior of H.

It can be that H doesn't return 0
It can be that H actaully does a correct simulation, and thus doesn't
abort its simulation.

You have a history of shading the truth, so you don't get a pass with
sloppy wording.

All statements must include the conditions that apply to them.