On 6/16/2022 1:49 PM, Mr Flibble wrote:
> On Thu, 16 Jun 2022 13:45:07 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/16/2022 1:32 PM, Mr Flibble wrote:
>>> On Thu, 16 Jun 2022 13:31:57 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 6/16/2022 1:30 PM, Mr Flibble wrote:
>>>>> On Thu, 16 Jun 2022 13:26:25 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 6/16/2022 1:22 PM, Mr Flibble wrote:
>>>>>>> On Thu, 16 Jun 2022 13:21:45 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 6/16/2022 1:11 PM, Mr Flibble wrote:
>>>>>>>>> On Thu, 16 Jun 2022 13:07:29 -0500
>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>
>>>>>>>>>> On 6/16/2022 1:02 PM, Mr Flibble wrote:
>>>>>>>>>>> On Thu, 16 Jun 2022 12:40:19 -0500
>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>
>>>>>>>>>>> It would be better if you actually addressed the content of
>>>>>>>>>>> people's posts. Your H is erroneous.
>>>>>>>>>>>
>>>>>>>>>>> /Flibble
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Competent software engineers will agree that
>>>>>>>>>> the following proves that H(P,P)==0 is correct.
>>>>>>>>>>
>>>>>>>>>> #include <stdint.h>
>>>>>>>>>> typedef void (*ptr)();
>>>>>>>>>>
>>>>>>>>>> void P(ptr x)
>>>>>>>>>> {
>>>>>>>>>> if (H(x, x))
>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>> return;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> int main()
>>>>>>>>>> {
>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> _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]
>>>>>>>>>>
>>>>>>>>>> (1) It is an easily verified fact that when we assume that H
>>>>>>>>>> is only an x86 emulator that the correctly emulated P never
>>>>>>>>>> reaches its "ret" instruction it remains stuck in repeated
>>>>>>>>>> cycles of emulation.
>>>>>>>>>>
>>>>>>>>>> (2) It is an easily verified fact that if H has been adapted
>>>>>>>>>> to correctly detect (in a finite number of steps) that the
>>>>>>>>>> correct and complete x86 emulation of its input would never
>>>>>>>>>> each its "ret" instruction that H could abort its emulation
>>>>>>>>>> and return 0 to report this.
>>>>>>>>>>
>>>>>>>>>> (3) When the halt status criteria is defined as correctly
>>>>>>>>>> determining whether or not an x86 emulated input would ever
>>>>>>>>>> reach its "ret" instruction then it becomes an easily
>>>>>>>>>> verified fact H(P,P) could correctly reject its input as
>>>>>>>>>> non-halting.
>>>>>>>>>>
>>>>>>>>>> Correct deductive inference proves that all of these things
>>>>>>>>>> are true without any need what-so-ever to see either the
>>>>>>>>>> source-code or the execution trace of H.
>>>>>>>>>>
>>>>>>>>>> The one thing that is not proved is whether or not an actual
>>>>>>>>>> encoded H(P,P) does indeed correctly determine that its input
>>>>>>>>>> would never reach its "ret" instruction as a pure function of
>>>>>>>>>> its inputs.
>>>>>>>>>
>>>>>>>>> Nope. If H(P,P) == 0 then P should halt.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>
>>>>>>>> Competent software engineers would understand that H(P,P)==0 is
>>>>>>>> correct and be unable to find any software engineering
>>>>>>>> mistakes.
>>>>>>>>
>>>>>>>> It is an easily verified fact that the correct and complete x86
>>>>>>>> emulation of the input to H(P,P) by H cannot possibly reach its
>>>>>>>> "ret" instruction.
>>>>>>>>
>>>>>>>> Since this is the criterion measure for returning 0 then
>>>>>>>> H(P,P)==0 has been proven to be correct on the basis of
>>>>>>>> software engineering.
>>>>>>>
>>>>>>> Nope. If H(P,P) == 0 then P should halt.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> People that are not competent software engineers and people that
>>>>>> prefer rebuttal to truth will avoid addressing the above
>>>>>> irrefutably correct reasoning.
>>>>>
>>>>> Your reasoning is incorrect. If H(P,P) == 0 then P should halt.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> Which one of these are you:
>>>>
>>>> People that are not competent software engineers and people that
>>>> prefer rebuttal to truth will avoid addressing the above
>>>> irrefutably correct reasoning.
>>>
>>> Your reasoning is incorrect. If H(P,P) == 0 then P should halt.
>>>
>>> /Flibble
>>>
>>
>> Since my reasoning is trivially proven to be correct:
>>
>> It is an easily verified fact that the correct and complete x86
>> emulation of the input to H(P,P) by H cannot possibly reach its
>> "ret" instruction.
>>
>> H returns 0 whenever the complete and correct x86 emulation of its
>> input would never reach the "ret" instruction of this input.
>>
>> Every possible rebuttal is simultaneously proven to be incorrect.
>
> Nope. If H(P,P) == 0 then P should halt.
>
> /Flibble
>

(X) It is an easily verified fact that the correct and complete x86
emulation of the input to H(P,P) by H cannot possibly reach its "ret"
instruction.

(Y) H returns 0 whenever the correct and complete x86 emulation of its
input would never reach the "ret" instruction of this input.

(Z) H(P,P)==0 is correct

When (X & Y) proves Z and we know X & Y then Z is proved.

Even you can understand that there is no escape from this last line.
Failing to acknowledge the correctness of this last line is sufficient
evidence of dishonesty.

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer