On 6/10/22 9:33 AM, olcott wrote:
> 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 WE CANNOT MOVE ON !!!

Why are you insisting on an apology for them telling the truth.

You DON'T have "A Simulating Halt Decider" (at least by the standard
definitions) because by normal English Grammer and composistion rules, a
Simulating Halt Decider needs to meet all the requirements of being a
Halt Decider, which H doesn't

Remember, a Halt Decider is DEFINED to answer about the behavior of the
actual Turing Machine, that has be represented in its input, being
applied to the input that is also specified in its input.

You have SPECIFICALLY claimed that the you H only needs to answer about
the behavior of its actual input, and tha you are defining that, at
least for the case of H(P,P) that that is NOT P(P).

Since you are specifically saying what you are calling a "Simulating
Halt Decider" doesn't need to meet the actual requirements of a Halt
Decider, what you are wanting to call a "Simulating Halt Decider" isn't
actually a Simulating Halt Decider.

What you are doing is exactly like the crazy person who wants to call
their dog a cat getting upset about someone saying they don't have a
cat. They DON'T have a cat, they have a Dog. In the say way, your H is
NOT actually "Simulating Halt Decider" but something else, because it
doesn't meet the definition, since you refuse to let it have the right
requirements.

This means in a real sense it isn't even an incorrect halt decider,
because you have defined that to domain of its inputs aren't the same
domain as a Halt Decider.

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