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

> > 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.
Therefore, "the input" is not the P the HP specified.

There are lots more "the input", POOH will fail.

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

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

You lied again. Your H (Halt7.c) will fail on this case. There are numerous
such OBVIOUS cases your H will fail.
You want to try more to see the truth?

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

On 7/29/2022 5:10 PM, 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
>
> You lied again. Your H (Halt7.c) will fail on this case. There are numerous
> such OBVIOUS cases your H will fail.
> You want to try more to see the truth?

Compile it for yourself with the source-code that you didn't believe
existed:

https://www.liarparadox.org/2022_07_22.zip
This is the complete system that compiles under:

Microsoft Visual Studio Community 2017
https://visualstudio.microsoft.com/vs/older-downloads/

It has not been recently compiled under UBUNTU

Halt.c must be compiled under windows because x86utm only accepts the
COFF object file output of the Microsoft C compiler. If you compile it
under Ubuntu it might work if the object file is correctly converted to
COFF format.

--
Copyright 2022 Pete Olcott

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

On 7/29/22 9: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.

A person who refuses to look at the refutations, just proves that they
are stuck in a lie to themselves.

I would interprete his WASTING of the 18 years as solid evidence that he
has some form of mental deficiency (perhaps self imposed) that is
preventing him from seeing the truth.

Part of the problem is he seems to have a strongly held core belief,
that he needs to realize is incorrect to accept the proof of the Halting
Problem.

He seems to prefer that the whole world is just broken rather than admit
that his idea of the definition of Truth might be wrong.

This means he can not accept what the world shows him is True, as that
means that his core belief would need to be false, and he can not accept
that.

On Saturday, 30 July 2022 at 00:15:36 UTC+2, olcott wrote:
> On 7/29/2022 5:10 PM, 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
> >
> > You lied again. Your H (Halt7.c) will fail on this case. There are numerous
> > such OBVIOUS cases your H will fail.
> > You want to try more to see the truth?
> Compile it for yourself with the source-code that you didn't believe
> existed:
>
> https://www.liarparadox.org/2022_07_22.zip
> This is the complete system that compiles under:
>
> Microsoft Visual Studio Community 2017
> https://visualstudio.microsoft.com/vs/older-downloads/
>
> It has not been recently compiled under UBUNTU
>
> Halt.c must be compiled under windows because x86utm only accepts the
> COFF object file output of the Microsoft C compiler. If you compile it
> under Ubuntu it might work if the object file is correctly converted to
> COFF format.

On 7/29/22 6:15 PM, olcott wrote:
> On 7/29/2022 5:10 PM, 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
>>
>> You lied again. Your H (Halt7.c) will fail on this case. There are
>> numerous
>> such OBVIOUS cases your H will fail.
>> You want to try more to see the truth?
>
> Compile it for yourself with the source-code that you didn't believe
> existed:
>
> https://www.liarparadox.org/2022_07_22.zip
> This is the complete system that compiles under:
>
> Microsoft Visual Studio Community 2017
> https://visualstudio.microsoft.com/vs/older-downloads/
>
> It has not been recently compiled under UBUNTU
>
> Halt.c must be compiled under windows because x86utm only accepts the
> COFF object file output of the Microsoft C compiler. If you compile it
> under Ubuntu it might work if the object file is correctly converted to
> COFF format.
>
>
>
>

On 7/29/2022 5:56 PM, Skep Dick wrote:
> On Saturday, 30 July 2022 at 00:15:36 UTC+2, olcott wrote:
>> On 7/29/2022 5:10 PM, 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
>>>
>>> You lied again. Your H (Halt7.c) will fail on this case. There are numerous
>>> such OBVIOUS cases your H will fail.
>>> You want to try more to see the truth?
>> Compile it for yourself with the source-code that you didn't believe
>> existed:
>>
>> https://www.liarparadox.org/2022_07_22.zip
>> This is the complete system that compiles under:
>>
>> Microsoft Visual Studio Community 2017
>> https://visualstudio.microsoft.com/vs/older-downloads/
>>
>> It has not been recently compiled under UBUNTU
>>
>> Halt.c must be compiled under windows because x86utm only accepts the
>> COFF object file output of the Microsoft C compiler. If you compile it
>> under Ubuntu it might work if the object file is correctly converted to
>> COFF format.
>
> There's simply no way to explain to an ignoramus that converting files from C to ASM to COFF is just different representations (implementations) of the exact same function.
> He's just translating the exact same computation into different languages.
>
> He doesn't understand the difference between syntax (what he's manipulating) and semantics (the meaning of the function which remains the same across languages).
>
> He doesn't even understand extensionality.
>
> https://en.wikipedia.org/wiki/Extensionality
>

On 7/29/22 7:41 PM, olcott wrote:
> On 7/29/2022 5:56 PM, Skep Dick wrote:
>> On Saturday, 30 July 2022 at 00:15:36 UTC+2, olcott wrote:
>>> On 7/29/2022 5:10 PM, 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
>>>>
>>>> You lied again. Your H (Halt7.c) will fail on this case. There are
>>>> numerous
>>>> such OBVIOUS cases your H will fail.
>>>> You want to try more to see the truth?
>>> Compile it for yourself with the source-code that you didn't believe
>>> existed:
>>>
>>> https://www.liarparadox.org/2022_07_22.zip
>>> This is the complete system that compiles under:
>>>
>>> Microsoft Visual Studio Community 2017
>>> https://visualstudio.microsoft.com/vs/older-downloads/
>>>
>>> It has not been recently compiled under UBUNTU
>>>
>>> Halt.c must be compiled under windows because x86utm only accepts the
>>> COFF object file output of the Microsoft C compiler. If you compile it
>>> under Ubuntu it might work if the object file is correctly converted to
>>> COFF format.
>>
>> There's simply no way to explain to an ignoramus that converting files
>> from C to ASM to COFF is just different representations
>> (implementations) of the exact same function.
>> He's just translating the exact same computation into different
>> languages.
>>
>> He doesn't understand the difference between syntax (what he's
>> manipulating) and semantics (the meaning of the function which remains
>> the same across languages).
>>
>> He doesn't even understand extensionality.
>>
>> https://en.wikipedia.org/wiki/Extensionality
>>
>
> *You can't even keep track of the issue at hand*
> *You can't even keep track of the issue at hand*
> *Here is the issue at hand*
> *Here is the issue at hand*
> *Here is the issue at hand*

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

On 7/30/22 6: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:
> }

On Saturday, 30 July 2022 at 13:33:37 UTC+2, richar...@gmail.com wrote:
> Yes, his H can handle the case of Infinite_Loop3() not being an infinite
> loop. The loop detection detects returning to a previous address that
> has been used, not just a backwards jump.

Which is precisely what Infinite Time Turing Machines do.

He's just using a different (and more powerful) model of computation to you.

Again, nothing interesting. That is what it means for computer A to be "more powerful" than computer B.

It means A can solve the halting problem for B.
It remains true that A cannot solve the halting problem for A.

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

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