On 7/30/22 11:17 AM, olcott wrote:
> On 7/30/2022 5:39 AM, wij wrote:
>> On Saturday, 30 July 2022 at 04:58:15 UTC+8, olcott wrote:
>>> On 7/29/2022 3:18 PM, wij wrote:
>>>> On Saturday, 30 July 2022 at 01:42:26 UTC+8, olcott wrote:
>>>>> On 7/29/2022 11:56 AM, wij wrote:
>>>>>> On Friday, 29 July 2022 at 23:20:42 UTC+8, olcott wrote:
>>>>>>> On 7/29/2022 8:18 AM, wij wrote:
>>>>>>>> On Tuesday, 26 July 2022 at 03:22:44 UTC+8, Mr Flibble wrote:
>>>>>>>>> How can we help Olcott understand that his "infinite recursion"
>>>>>>>>> is a
>>>>>>>>> property of his simulating halting decider and NOT a property
>>>>>>>>> of the
>>>>>>>>> input passed to his decider? His error is compounded by him
>>>>>>>>> incorrectly mapping his decider's recursion to the input being
>>>>>>>>> non-halting.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>
>>>>>>>> olcott had studied the topic "refutation of the HP proof" for 18
>>>>>>>> years.
>>>>>>>> I think something is wrong if no one can make olcott believe the
>>>>>>>> HP proof is
>>>>>>>> very solidly valid, and his proof is very bogus.
>>>>>>> _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]
>>>>>>>
>>>>>>> *Halt Deciding Principle* (the key element of all of my work)
>>>>>>> Every simulating halt decider that correctly simulates its input
>>>>>>> until
>>>>>>> it correctly predicts that this simulated input would never
>>>>>>> terminate
>>>>>>> normally, (by reaching its final state) correctly rejects this
>>>>>>> input as
>>>>>>> non-halting.
>>>>>>>
>>>>>>> The above *Halt Deciding Principle* defeats the otherwise
>>>>>>> "impossible"
>>>>>>> "pathological" input shown below:
>>>>>>> For any program H that might determine if programs halt, a
>>>>>>> "pathological"
>>>>>>> program P, called with some input, can pass its own source and
>>>>>>> its input
>>>>>>> to H and then specifically do the opposite of what H predicts P
>>>>>>> will do.
>>>>>>> *No H can exist that handles this case*
>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>>
>>>>>>> H correctly determines that its correctly simulated input would
>>>>>>> never
>>>>>>> reach the final state of this input: "ret" thus never halt even
>>>>>>> in an
>>>>>>> infinite number of simulated steps.
>>>>>>> --
>>>>>>> Copyright 2022 Pete Olcott
>>>>>>>
>>>>>>> "Talent hits a target no one else can hit;
>>>>>>> Genius hits a target no one else can see."
>>>>>>> Arthur Schopenhauer
>>>>>>
>>>>>> You said "H correctly determines that its correctly simulated
>>>>>> input would never
>>>>>> reach the final state of this input ..."
>>>>>> So, the honest answer is: H is undecidable (never halts).
>>>>> No dumb bunny that it not what that means.
>>>>> "H correctly determines that its correctly simulated input would never
>>>>> reach the final state of this input ..."
>>>>> because it is a freaking infinite loop:
>>>>> void Infinite_Loop()
>>>>> {
>>>>> HERE: goto HERE;
>>>>> }
>>>>> int main()
>>>>> {
>>>>> Output("Input_Halts = ", H0((u32)Infinite_Loop));
>>>>> }
>>>>>
>>>>> _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]
>>>>
>>>> Can POOH decide this Infinite_Loop() is an infinite loop?
>>>>
>>>> void Infinite_Loop2()
>>>> {
>>>> L1: goto L3;
>>>> L2: goto L1;
>>>> L3: goto L2;
>>>> }
>>>>
>>> *Yes that input is in the domain of my halt decider*
>>>
>>> _Infinite_Loop2()
>>> [00000ffe](01) 55 push ebp
>>> [00000fff](02) 8bec mov ebp,esp
>>> [00001001](02) eb02 jmp 00001005
>>> [00001003](02) ebfc jmp 00001001
>>> [00001005](02) ebfc jmp 00001003
>>> [00001007](01) 5d pop ebp
>>> [00001008](01) c3 ret
>>> Size in bytes:(0011) [00001008]
>>>
>>> _main()
>>> [0000100e](01) 55 push ebp
>>> [0000100f](02) 8bec mov ebp,esp
>>> [00001011](05) 68fe0f0000 push 00000ffe
>>> [00001016](05) 68fe0f0000 push 00000ffe
>>> [0000101b](05) e86efeffff call 00000e8e
>>> [00001020](03) 83c408 add esp,+08
>>> [00001023](01) 50 push eax
>>> [00001024](05) 684f040000 push 0000044f
>>> [00001029](05) e840f4ffff call 0000046e
>>> [0000102e](03) 83c408 add esp,+08
>>> [00001031](02) 33c0 xor eax,eax
>>> [00001033](01) 5d pop ebp
>>> [00001034](01) c3 ret
>>> Size in bytes:(0039) [00001034]
>>> machine stack stack machine assembly
>>> address address data code language
>>> ======== ======== ======== ========= =============
>>> [0000100e][00101a3d][00000000] 55 push ebp
>>> [0000100f][00101a3d][00000000] 8bec mov ebp,esp
>>> [00001011][00101a39][00000ffe] 68fe0f0000 push 00000ffe
>>> [00001016][00101a35][00000ffe] 68fe0f0000 push 00000ffe
>>> [0000101b][00101a31][00001020] e86efeffff call 00000e8e
>>>
>>> H: Begin Simulation Execution Trace Stored at:111ae9
>>> Address_of_H:e8e
>>> [00000ffe][00111ad5][00111ad9] 55 push ebp
>>> [00000fff][00111ad5][00111ad9] 8bec mov ebp,esp
>>> [00001001][00111ad5][00111ad9] eb02 jmp 00001005
>>> [00001005][00111ad5][00111ad9] ebfc jmp 00001003
>>> [00001003][00111ad5][00111ad9] ebfc jmp 00001001
>>> H: Infinite Loop Detected Simulation Stopped
>>>
>>> [00001020][00101a3d][00000000] 83c408 add esp,+08
>>> [00001023][00101a39][00000000] 50 push eax
>>> [00001024][00101a35][0000044f] 684f040000 push 0000044f
>>> [00001029][00101a35][0000044f] e840f4ffff call 0000046e
>>> Input_Halts = 0
>>> [0000102e][00101a3d][00000000] 83c408 add esp,+08
>>> [00001031][00101a3d][00000000] 33c0 xor eax,eax
>>> [00001033][00101a41][00000018] 5d pop ebp
>>> [00001034][00101a45][00000000] c3 ret
>>> Number of Instructions Executed(767) == 11 Pages
>>>>>> In Halt7.c, H detects certain machine codes makes H a non-pure
>>>>>> function, lots
>>>>>> of problems caused by this 'criteria', to say the least.
>>>>> *One thing at a time, first you must understand that this means*
>>>>> "H correctly determines that its correctly simulated input would never
>>>>> reach the final state of this input ..."
>>>>> Mans that H correctly determine that its input is non-halting.
>>>>
>>>> "the input" is not an arbitrary input.
>>>> "the input" P does not exist before H is constructed, you cannot
>>>> hard-code it.
>>> *Here is it hard-coded*
>>> Are you like the nutty Trumpites that simply ignore the fact that there
>>> was no evidence of consequential election fraud that was even presented
>>> in any of his 63 court cases?
>>>
>>> His lawyers knew that if presented the baseless propaganda that he has
>>> been telling the public they would be found guilty of perjury. They knew
>>> this so the refrained from presenting his propaganda and there was no
>>> actual evidence left over to present.
>>>
>>> *Here is it hard-coded*
>>> *Here is it hard-coded*
>>> *Here is it hard-coded*
>>> *Here is it hard-coded*
>>>
>>> _P()
>>> [0000143b](01) 55 push ebp
>>> [0000143c](02) 8bec mov ebp,esp
>>> [0000143e](01) 51 push ecx
>>> [0000143f](03) 8b4508 mov eax,[ebp+08]
>>> [00001442](01) 50 push eax
>>> [00001443](03) 8b4d08 mov ecx,[ebp+08]
>>> [00001446](01) 51 push ecx
>>> [00001447](05) e8affcffff call 000010fb
>>> [0000144c](03) 83c408 add esp,+08
>>> [0000144f](03) 8945fc mov [ebp-04],eax
>>> [00001452](04) 837dfc00 cmp dword [ebp-04],+00
>>> [00001456](02) 7402 jz 0000145a
>>> [00001458](02) ebfe jmp 00001458
>>> [0000145a](02) 8be5 mov esp,ebp
>>> [0000145c](01) 5d pop ebp
>>> [0000145d](01) c3 ret
>>> Size in bytes:(0035) [0000145d]
>>>> Therefore, "the input" is not the P the HP specified.
>>>>
>>>> There are lots more "the input", POOH will fail.
>>> --
>>> Copyright 2022 Pete Olcott
>>>
>>> "Talent hits a target no one else can hit;
>>> Genius hits a target no one else can see."
>>> Arthur Schopenhauer
>>
>>   Can POOH decide Infinite_Loop2() and Infinite_Loop3() are infinite
>> loops?
>>
>> void Infinite_Loop2() {
>> L1: goto L3;
>> L2: goto L1;
>> L3: goto L2;
>> }
>>
>> void Infinite_Loop3() {
>> L1: goto L3;
>> L2: goto L4;
>> L3: goto L2;
>> L4:
>> }
>
> I already answered Infinite_Loop2() and you did not believe my execution
> trace. Here is the execution trace of the corrected syntax for
> Infinite_Loop3() which proves to be misnamed because it halts.
>

And all of this is Herring in Red Sauce since H being able to handle
these SIMPLE problems says NOTHING about it being able to hand the
"impossible" program that uses a copy of H to defeat H, as is allowed by
computation theory.

A LOT of "rules" that you might think of as "obvious" fail in that sort
of case, which is why "obvious" isn't actually a "thing" when doing a
formal proof.