On 6/10/2022 8:29 AM, Mr Flibble wrote:
> On Fri, 10 Jun 2022 08:27:28 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/10/2022 8:23 AM, Mr Flibble wrote:
>>> On Fri, 10 Jun 2022 08:05:57 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 6/10/2022 6:11 AM, Mr Flibble wrote:
>>>>> On Thu, 9 Jun 2022 17:35:05 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 6/9/2022 5:27 PM, Mr Flibble wrote:
>>>>>>> On Thu, 9 Jun 2022 17:18:38 -0500
>>>>>>> olcott <NoOne@NoWhere.com> 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.
>>>>>>>
>>>>>>> I am saying that your H is not a halting decider; I am saying
>>>>>>> that your H is just a simulation detector, S.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> You are saying that you simply "don't believe in" simulating halt
>>>>>> deciders.
>>>>>
>>>>> You haven't got a simulating halt decider, what you have got is a
>>>>> simulation detector.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> It is an easily verified fact that H does correctly decide the halt
>>>> status of its input.
>>>>
>>>> void Infinite_Loop()
>>>> {
>>>> HERE: goto HERE;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>> Output("Input_Halts = ", H0(Infinite_Loop));
>>>> }
>>>>
>>>> _Infinite_Loop()
>>>> [00001342](01) 55 push ebp
>>>> [00001343](02) 8bec mov ebp,esp
>>>> [00001345](02) ebfe jmp 00001345
>>>> [00001347](01) 5d pop ebp
>>>> [00001348](01) c3 ret
>>>> Size in bytes:(0007) [00001348]
>>>>
>>>> _main()
>>>> [00001372](01) 55 push ebp
>>>> [00001373](02) 8bec mov ebp,esp
>>>> [00001375](05) 6842130000 push 00001342
>>>> [0000137a](05) e833fdffff call 000010b2
>>>> [0000137f](03) 83c404 add esp,+04
>>>> [00001382](01) 50 push eax
>>>> [00001383](05) 6823040000 push 00000423
>>>> [00001388](05) e8e5f0ffff call 00000472
>>>> [0000138d](03) 83c408 add esp,+08
>>>> [00001390](02) 33c0 xor eax,eax
>>>> [00001392](01) 5d pop ebp
>>>> [00001393](01) c3 ret
>>>> Size in bytes:(0034) [00001393]
>>>>
>>>> machine stack stack machine assembly
>>>> address address data code language
>>>> ======== ======== ======== ========= =============
>>>> [00001372][0010228f][00000000] 55 push ebp
>>>> [00001373][0010228f][00000000] 8bec mov ebp,esp
>>>> [00001375][0010228b][00001342] 6842130000 push 00001342 // push
>>>> _Infinite_Loop
>>>> [0000137a][00102287][0000137f] e833fdffff call 000010b2 // call H0
>>>>
>>>> Begin Local Halt Decider Simulation Execution Trace Stored
>>>> at:212343 [00001342][00212333][00212337] 55 push ebp
>>>> [00001343][00212333][00212337] 8bec mov ebp,esp
>>>> [00001345][00212333][00212337] ebfe jmp 00001345
>>>> [00001345][00212333][00212337] ebfe jmp 00001345
>>>> Local Halt Decider: Infinite Loop Detected Simulation Stopped
>>>>
>>>> [0000137f][0010228f][00000000] 83c404 add esp,+04
>>>> [00001382][0010228b][00000000] 50 push eax
>>>> [00001383][00102287][00000423] 6823040000 push 00000423
>>>> [00001388][00102287][00000423] e8e5f0ffff call 00000472
>>>> Input_Halts = 0
>>>> [0000138d][0010228f][00000000] 83c408 add esp,+08
>>>> [00001390][0010228f][00000000] 33c0 xor eax,eax
>>>> [00001392][00102293][00100000] 5d pop ebp
>>>> [00001393][00102297][00000004] c3 ret
>>>> Number of Instructions Executed(680)
>>>>
>>>> int Sum(int X, int Y)
>>>> {
>>>> return X + Y;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>> Output("Input_Halts = ", H2(Sum, 3, 4));
>>>> }
>>>>
>>>> _Sum()
>>>> [000012b6](01) 55 push ebp
>>>> [000012b7](02) 8bec mov ebp,esp
>>>> [000012b9](03) 8b4508 mov eax,[ebp+08]
>>>> [000012bc](03) 03450c add eax,[ebp+0c]
>>>> [000012bf](01) 5d pop ebp
>>>> [000012c0](01) c3 ret
>>>> Size in bytes:(0011) [000012c0]
>>>>
>>>> _main()
>>>> [00001316](01) 55 push ebp
>>>> [00001317](02) 8bec mov ebp,esp
>>>> [00001319](02) 6a04 push +04
>>>> [0000131b](02) 6a03 push +03
>>>> [0000131d](05) 68b6120000 push 000012b6
>>>> [00001322](05) e85ffaffff call 00000d86
>>>> [00001327](03) 83c40c add esp,+0c
>>>> [0000132a](01) 50 push eax
>>>> [0000132b](05) 6807040000 push 00000407
>>>> [00001330](05) e821f1ffff call 00000456
>>>> [00001335](03) 83c408 add esp,+08
>>>> [00001338](02) 33c0 xor eax,eax
>>>> [0000133a](01) 5d pop ebp
>>>> [0000133b](01) c3 ret
>>>> Size in bytes:(0038) [0000133b]
>>>>
>>>> machine stack stack machine assembly
>>>> address address data code language
>>>> ======== ======== ======== ========= =============
>>>> ...[00001316][001021d7][00000000] 55 push ebp
>>>> ...[00001317][001021d7][00000000] 8bec mov ebp,esp
>>>> ...[00001319][001021d3][00000004] 6a04 push +04
>>>> ...[0000131b][001021cf][00000003] 6a03 push +03
>>>> ...[0000131d][001021cb][000012b6] 68b6120000 push 000012b6
>>>> ...[00001322][001021c7][00001327] e85ffaffff call 00000d86
>>>>
>>>> Begin Local Halt Decider Simulation Execution Trace Stored
>>>> at:21228b ...[000012b6][00212273][00212277] 55 push
>>>> ebp ...[000012b7][00212273][00212277] 8bec mov ebp,esp
>>>> ...[000012b9][00212273][00212277] 8b4508 mov eax,[ebp+08]
>>>> ...[000012bc][00212273][00212277] 03450c add eax,[ebp+0c]
>>>> ...[000012bf][00212277][00000e54] 5d pop ebp
>>>> ...[000012c0][0021227b][00000003] c3 ret
>>>> ...[00001327][001021d7][00000000] 83c40c add esp,+0c
>>>> ...[0000132a][001021d3][00000001] 50 push eax
>>>> ...[0000132b][001021cf][00000407] 6807040000 push 00000407
>>>> ---[00001330][001021cf][00000407] e821f1ffff call 00000456
>>>> Input_Halts = 1
>>>> ...[00001335][001021d7][00000000] 83c408 add esp,+08
>>>> ...[00001338][001021d7][00000000] 33c0 xor eax,eax
>>>> ...[0000133a][001021db][00100000] 5d pop ebp
>>>> ...[0000133b][001021df][00000004] c3 ret
>>>> Number of Instructions Executed(660)
>>>
>>> All you are showing here is that your H can decide the halt status
>>> of two trivial cases however you have not shown that H can decide
>>> the halt status of non-trivial cases.
>>>
>>
>> You said:
>> "You haven't got a simulating halt decider"
>> Apologize and we can move on.
>
> I posted four paragraphs but you ignored three of them. Lets try again.
>

If you don't apologize then wee can move on.

> All you are showing here is that your H can decide the halt status of
> two trivial cases however you have not shown that H can decide the halt
> status of non-trivial cases.
>
> Publish the source code of your halt decider so we can see what classes
> of programs your H can decide.
>
> I am interested in deciding the halt status of programs containing
> non-trivial branching logic predicated on arbitrary program input.
>
> Crucially if your H cannot return an answer for an arbitrary
> non-halting program in finite time then it isn't a halt decider.
>
> /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