On Sunday, July 3, 2022 at 11:46:29 AM UTC-4, olcott wrote:
> On 7/1/2022 10:24 AM, Dennis Bush wrote:
> > On Friday, July 1, 2022 at 11:05:19 AM UTC-4, olcott wrote:
> >> On 7/1/2022 9:48 AM, Dennis Bush wrote:
> >>> On Friday, July 1, 2022 at 10:22:48 AM UTC-4, olcott wrote:
> >>>> On 7/1/2022 8:50 AM, Dennis Bush wrote:
> >>>>> On Friday, July 1, 2022 at 9:38:06 AM UTC-4, olcott wrote:
> >>>>>> On 7/1/2022 8:18 AM, Dennis Bush wrote:
> >>>>>>> On Friday, July 1, 2022 at 8:55:01 AM UTC-4, olcott wrote:
> >>>>>>>> On 6/30/2022 6:17 PM, Dennis Bush wrote:
> >>>>>>>>> On Thursday, June 30, 2022 at 7:11:01 PM UTC-4, olcott wrote:
> >>>>>>>>>> On 6/30/2022 6:05 PM, Dennis Bush wrote:
> >>>>>>>>>>> On Thursday, June 30, 2022 at 6:57:12 PM UTC-4, olcott wrote:
> >>>>>>>>>>>> On 6/30/2022 5:26 PM, Dennis Bush wrote:
> >>>>>>>>>>>>> On Thursday, June 30, 2022 at 6:23:56 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>> On 6/30/2022 5:09 PM, Dennis Bush wrote:
> >>>>>
> >>>>>>>>>>>>>> Perhaps you are simply not bright enough to understand that aborted or
> >>>>>>>>>>>>>> not the emulated input never reaches its "ret" instruction..
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Then you believe that Ha3(N,5)==0 is correct because the emulated input never reaches its "ret" instruction, correct?
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> If not, then explain in detail why it is wrong. Failure to do so will be taken as you asserting that this is correct.
> >>>>>>>>>>>> The problem is not that you are not bright enough the problem is that
> >>>>>>>>>>>> you are a liar that continues to try and get away with the strawman
> >>>>>>>>>>>> deception.
> >>>>>>>>>>>
> >>>>>>>>>>> You said "aborted or not the emulated input never reaches its "ret" instruction". There is no "not" since the fixed algorithm of Ha aborts, so you're saying that because Ha aborts that causes the "ret" instruction to not be reached which is your criteria for returning 0.
> >>>>>>>>>> *This is necessarily true thus impossibly false*
> >>>>>>>>>> Every simulating halt decider that correctly simulates its input until
> >>>>>>>>>> it correctly determines that this simulated input would never reach its
> >>>>>>>>>> final state, correctly rejects this input as non-halting.
> >>>>>>>>>
> >>>>>>>>> So now you're back to "this" simulated input, which means aborting and reporting non-halting is necessarily correct.
> >>>>>>>>>
> >>>>>>>>> Which means you've just affirmed that you agree that Ha3(N,5)==0 is correct.
> >>>>>>>> A dog is an animal is correct thus anyone that disagrees is necessarily
> >>>>>>>> incorrect.
> >>>>>>>> *This is necessarily true thus impossibly false*
> >>>>>>>> Every simulating halt decider that correctly simulates its input until
> >>>>>>>> it correctly determines that this simulated input would never reach its
> >>>>>>>> final state,
> >>>>>>>
> >>>>>>> In other words, for Ha(Pa,Pa) the fixed algorithm of Ha determines if it is able to simulate its input to a final state. It cannot, so you assert that Ha(Pa,Pa)==0 is correct.
> >>>>>> It is not that Ha(Pa,Pa) does not have the ability to simulate its input
> >>>>>> until its input reaches a final state it is the fact that P is calling H
> >>>>>> in infinite recursion that prevents P from ever reaching its final
> >>>>>> state. H sees this and rejects P as non-halting.
> >>>>>
> >>>>> Pa is not calling Ha in infinite recursion. Since Ha is a pure function of its inputs (or at least it should be), Ha(Pa,Pa) will *always* return 0 in all contexts.
> >>>>
> >>>> *This is necessarily true thus impossibly false*
> >>>> Every simulating halt decider that correctly simulates its input until
> >>>> it correctly determines that this simulated input would never reach its
> >>>> final state, correctly rejects this input as non-halting.
> >>>
> >>> So you're just repeating your original point instead of stating why I'm wrong, which means you have no rebuttal.
> >>>
> >>>
> >>>> People that disagree with verified facts are either stupid or liars and
> >>>> you are not stupid.
> >>>>> So a correct simulation of Pa will correctly simulate the call to Ha which aborts *its* internal simulation, breaking the cycle, and will return 0, which causes the simulated Pa to halt.
> >>>>>
> >>>>> This proves that Ha(Pa,Pa)==0 is wrong.
> >>>>>
> >>>>>>
> >>>>>> _Infinite_Loop()
> >>>>>> [00001102](01) 55 push ebp
> >>>>>> [00001103](02) 8bec mov ebp,esp
> >>>>>> [00001105](02) ebfe jmp 00001105
> >>>>>> [00001107](01) 5d pop ebp
> >>>>>> [00001108](01) c3 ret
> >>>>>> Size in bytes:(0007) [00001108]
> >>>>>>
> >>>>>> It is not that H0(_Infinite_Loop) does not have the ability to simulate
> >>>>>> its input until its input reaches a final state it is the fact that
> >>>>>> _Infinite_Loop species an infinite loop that prevents _Infinite_Loop
> >>>>>> from ever reaching its final state.
> >>>>>
> >>>>> Which can be seen in an actual complete simulation, i.e. UTM(_Infinite_Loop), which dictates that returning 0 is correct.
> >>>>>
> >>>> int Simulate(u32 P, u32 I)
> >>>> {
> >>>> ((int(*)(int))P)(I);
> >>>> return 1;
> >>>> }
> >>>>
> >>>> void Px(u32 x)
> >>>> {
> >>>> if (Simulate(x, x))
> >>>> HERE: goto HERE;
> >>>> return;
> >>>> }
> >>>>
> >>>> int main()
> >>>> {
> >>>> Output("Input_Halts = ", H((u32)Px, (u32)Px));
> >>>> }
> >>>>
> >>>> _Simulate()
> >>>> [00001152](01) 55 push ebp
> >>>> [00001153](02) 8bec mov ebp,esp
> >>>> [00001155](03) 8b450c mov eax,[ebp+0c]
> >>>> [00001158](01) 50 push eax
> >>>> [00001159](03) ff5508 call dword [ebp+08]
> >>>> [0000115c](03) 83c404 add esp,+04
> >>>> [0000115f](05) b801000000 mov eax,00000001
> >>>> [00001164](01) 5d pop ebp
> >>>> [00001165](01) c3 ret
> >>>> Size in bytes:(0020) [00001165]
> >>>>
> >>>> _Px()
> >>>> [00001172](01) 55 push ebp
> >>>> [00001173](02) 8bec mov ebp,esp
> >>>> [00001175](03) 8b4508 mov eax,[ebp+08]
> >>>> [00001178](01) 50 push eax
> >>>> [00001179](03) 8b4d08 mov ecx,[ebp+08]
> >>>> [0000117c](01) 51 push ecx
> >>>> [0000117d](05) e8d0ffffff call 00001152
> >>>> [00001182](03) 83c408 add esp,+08
> >>>> [00001185](02) 85c0 test eax,eax
> >>>> [00001187](02) 7402 jz 0000118b
> >>>> [00001189](02) ebfe jmp 00001189
> >>>> [0000118b](01) 5d pop ebp
> >>>> [0000118c](01) c3 ret
> >>>> Size in bytes:(0027) [0000118c]
> >>>>
> >>>> _main()
> >>>> [000011b2](01) 55 push ebp
> >>>> [000011b3](02) 8bec mov ebp,esp
> >>>> [000011b5](05) 6872110000 push 00001172
> >>>> [000011ba](05) 6872110000 push 00001172
> >>>> [000011bf](05) e8aefdffff call 00000f72
> >>>> [000011c4](03) 83c408 add esp,+08
> >>>> [000011c7](01) 50 push eax
> >>>> [000011c8](05) 68a3040000 push 000004a3
> >>>> [000011cd](05) e820f3ffff call 000004f2
> >>>> [000011d2](03) 83c408 add esp,+08
> >>>> [000011d5](02) 33c0 xor eax,eax
> >>>> [000011d7](01) 5d pop ebp
> >>>> [000011d8](01) c3 ret
> >>>> Size in bytes:(0039) [000011d8]
> >>>> machine stack stack machine assembly
> >>>> address address data code language
> >>>> ======== ======== ======== ========= =============
> >>>> [000011b2][00101f43][00000000] 55 push ebp
> >>>> [000011b3][00101f43][00000000] 8bec mov ebp,esp
> >>>> [000011b5][00101f3f][00001172] 6872110000 push 00001172
> >>>> [000011ba][00101f3b][00001172] 6872110000 push 00001172
> >>>> [000011bf][00101f37][000011c4] e8aefdffff call 00000f72
> >>>>
> >>>> H: Begin Simulation Execution Trace Stored at:211ff7
> >>>> Address_of_H:f72
> >>>> [00001172][00211fe3][00211fe7] 55 push ebp
> >>>> [00001173][00211fe3][00211fe7] 8bec mov ebp,esp
> >>>> [00001175][00211fe3][00211fe7] 8b4508 mov eax,[ebp+08]
> >>>> [00001178][00211fdf][00001172] 50 push eax
> >>>> [00001179][00211fdf][00001172] 8b4d08 mov ecx,[ebp+08]
> >>>> [0000117c][00211fdb][00001172] 51 push ecx
> >>>> [0000117d][00211fd7][00001182] e8d0ffffff call 00001152
> >>>> [00001152][00211fd3][00211fe3] 55 push ebp
> >>>> [00001153][00211fd3][00211fe3] 8bec mov ebp,esp
> >>>> [00001155][00211fd3][00211fe3] 8b450c mov eax,[ebp+0c]
> >>>> [00001158][00211fcf][00001172] 50 push eax
> >>>> Calling:_Px()
> >>>> Decode_Control_Flow_Instruction([00000008][00211fd3][00001172])
> >>>> [00001159][00211fcb][0000115c] ff5508 call dword [ebp+08]
> >>>> [00001172][00211fc7][00211fd3] 55 push ebp
> >>>> [00001173][00211fc7][00211fd3] 8bec mov ebp,esp
> >>>> [00001175][00211fc7][00211fd3] 8b4508 mov eax,[ebp+08]
> >>>> [00001178][00211fc3][00001172] 50 push eax
> >>>> [00001179][00211fc3][00001172] 8b4d08 mov ecx,[ebp+08]
> >>>> [0000117c][00211fbf][00001172] 51 push ecx
> >>>> [0000117d][00211fbb][00001182] e8d0ffffff call 00001152
> >>>> H: Infinite Recursion Detected Simulation Stopped
> >>>>
> >>>> [000011c4][00101f43][00000000] 83c408 add esp,+08
> >>>> [000011c7][00101f3f][00000000] 50 push eax
> >>>> [000011c8][00101f3b][000004a3] 68a3040000 push 000004a3
> >>>> [000011cd][00101f3b][000004a3] e820f3ffff call 000004f2
> >>>> Input_Halts = 0
> >>>> [000011d2][00101f43][00000000] 83c408 add esp,+08
> >>>> [000011d5][00101f43][00000000] 33c0 xor eax,eax
> >>>> [000011d7][00101f47][00100000] 5d pop ebp
> >>>> [000011d8][00101f4b][00000000] c3 ret
> >>>> Number of Instructions Executed(2202) == 33 Pages
> >>>>>> H sees this and rejects
> >>>>>> _Infinite_Loop as non-halting.
> >>>>>> --
> >>>
> >>> This is not Ha(Pa,Pa). Pa calls Ha which has abort logic. Simulate is the same as what was called Hn. So Px is calling Hn, which means that Px is Pn.
> >>>
> >>> So the call in main is actually Ha(Pn,Pn). Pn(Pn) does not halt, nor does UTM(Pn,Pn), so Ha(Pn,Pn)==0 is correct. But's that's not the case we care about. We care about Ha(Pa,Pa). And since Pa(Pa) halts as does UTM(Pa,Pa), Ha(Pa,Pa)==0 is incorrect.
> >>>
> >>>
> >> Ha(Pa,Pa) correctly predicts that its complete and correct x86 emulation
> >> of its input would never reach the "ret" instruction of this input.
> >> <snipped useless repeat of original point>
> >
> > This is nonsense because "[Ha's] complete and correct x86 emulation of its input" does not exist since the fixed algorithm of Ha aborts.
>
> *This is necessarily true thus impossibly false*
> Every simulating halt decider that correctly simulates its input until
> it correctly predicts that this simulated input would never reach its
> final state, correctly rejects this input as non-halting.

On 7/3/22 11:46 AM, olcott wrote:
> *This is necessarily true thus impossibly false*
> Every simulating halt decider that correctly simulates its input until
> it correctly predicts that this simulated input would never reach its
> final state, correctly rejects this input as non-halting.

Yes, but you haven't established that ANY simulating Halt decider has
actually correctly predicted that this particular input would never
reach its final state.

The problem of course being that if the simulating halt decider tries to
predict (correctly or not) that this particular input is non-halting,
that because of the "pathological" (but valid) usage of a copy of that
decider by the input, it becomes halting, so there can never be a
correct prediction of non-halting as it will always be wrong.

P uses its copy of H, as allowed, to behave contrary to the decision of
H, so H can never give a correct prediction.

The ONLY way that H can prevent itself from giving an incorrect answer,
is to not answer, but that violates H's requirement to be a decider.