*This is refers to H(P,P)==0 where H and P are functions in C*

I believe I have learned something valuable from you:
that by simulation, and by simulations within simulations,
non-halting can sometimes be detected, and in particular,
it can be detected in the program used in the classical
proof of incomputability.

*Halting problem proofs refuted on the basis of software engineering* ?

https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering

--
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 8/19/2022 5:58 AM, Richard Damon wrote:
> On 8/18/22 11:35 PM, olcott wrote:
>> On 8/18/2022 10:23 PM, Richard Damon wrote:
>>> On 8/18/22 11:14 PM, olcott wrote:
>>>> On 8/18/2022 10:12 PM, Richard Damon wrote:
>>>>> On 8/18/22 10:56 PM, olcott wrote:
>>>>>> On 8/18/2022 9:02 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 8/18/22 9:20 PM, olcott wrote:
>>>>>>>> On 8/18/2022 8:04 PM, Skep Dick wrote:
>>>>>>>>> On Friday, 19 August 2022 at 02:12:26 UTC+2, olcott wrote:
>>>>>>>>>> On 8/18/2022 7:05 PM, Skep Dick wrote:
>>>>>>>>>>> On Friday, 19 August 2022 at 01:51:13 UTC+2, olcott wrote:
>>>>>>>>>>>> My system is correct from a software engineering point of view.
>>>>>>>>>>>> H does correctly determine that the actual behavior of its
>>>>>>>>>>>> actual input
>>>>>>>>>>>> specifies a sequence of instructions that never reach their
>>>>>>>>>>>> final state.
>>>>>>>>>>> Your program doesn't determine that the input NEVER (key
>>>>>>>>>>> word!!!) reach their final state.
>>>>>>>>>>>
>>>>>>>>>>> Your program determines that input doesn't reach its final
>>>>>>>>>>> state within N number of CPU cycles.
>>>>>>>>>>>
>>>>>>>>>> When-so-ever the partial simulation of a machine description
>>>>>>>>>> correctly
>>>>>>>>>> matches a correct infinite behavior pattern then it is certain
>>>>>>>>>> that this
>>>>>>>>>> machine description specifies infinite behavior.
>>>>>>>>>
>>>>>>>>> You can correctly put as correct many correct uses of the
>>>>>>>>> correct word correct but correct is not correct to be correct
>>>>>>>>> correct correct correct.
>>>>>>>>>
>>>>>>>>> You are incorrect.
>>>>>>>>
>>>>>>>> *Since there are no mistakes no one can point out any mistakes*
>>>>>>>> *Since there are no mistakes no one can point out any mistakes*
>>>>>>>> *Since there are no mistakes no one can point out any mistakes*
>>>>>>>
>>>>>>> People HAVE pointed out the mistakes, but you are apparently too
>>>>>>> dumb to understand the problem.
>>>>>>>
>>>>>>>>
>>>>>>>> (a) The correct partial simulation of a machine description
>>>>>>>> (b) Correctly matches
>>>>>>>> (c) A correct infinite behavior pattern
>>>>>>>
>>>>>>> But the pattern you suggest is NOT corrct.
>>>>>>>
>>>>>>
>>>>>> void Infinite_Recursion(int N)
>>>>>> {
>>>>>>    Infinite_Recursion(N);
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>>    Output("Input_Halts = ", H((u32)Infinite_Recursion, 0x777));
>>>>>> }
>>>>>>
>>>>>> *TRY AND FIND ANY EXAMPLE OF FALSE POSITIVE*
>>>>>> (1) Infinite_Recursion() is called twice in sequence from the same
>>>>>> machine address of Infinite_Recursion() .
>>>>>> (2) With the same arguments to Infinite_Recursion()
>>>>>> (3) With no control flow instructions between the invocation of
>>>>>> Infinite_Recursion()  and the call to Infinite_Recursion() from
>>>>>> Infinite_Recursion()
>>>>>>
>>>>>> The fact that no false positives exist proves that there are no
>>>>>> false positives. Every time that the above pattern is matched is a
>>>>>> case of infinite recursion.
>>>>>
>>>>> Fallacy of the Strawman.
>>>>>
>>>>> I am not saying it doesn't work for Recursion, it doesn't work for
>>>>> the infinite simulation pattern.
>>>>>
>>>>
>>>> So then you agree that this reasoning is correct as long as the
>>>> behavior pattern is correct?
>>>>
>>>> (a) The correct partial simulation of a machine description
>>>> (b) Correctly matches
>>>> (c) A correct infinite behavior pattern
>>>> (d) Then this machine description specifies infinite behavior.
>>>>
>>>>
>>>>
>>>
>>> If you HAD a correct infinite simulation pattern, then yes, if you
>>> detect it, (BY DEFINITION) the behavior would be infinite, as that is
>>> the definition of correct.
>>>
>>
>> I am surprised that you say that, most people here seem to be happy to
>> disagree with verified facts and logical necessity as long as they can
>> do this as part of their rebuttal to make sure that they always
>> disagree with everything that I say.
>>
>> Do you agree that this infinite recursion behavior pattern will never
>> have any false positive matches?
>>
>> void Infinite_Recursion(int N)
>> {
>>    Infinite_Recursion(N);
>> }
>>
>> int main()
>> {
>>    Output("Input_Halts = ", H((u32)Infinite_Recursion, 0x777));
>> }
>>
>> _Infinite_Recursion()
>> [000010f2](01)  55         push ebp
>> [000010f3](02)  8bec       mov ebp,esp
>> [000010f5](03)  8b4508     mov eax,[ebp+08]
>> [000010f8](01)  50         push eax
>> [000010f9](05)  e8f4ffffff call 000010f2
>> [000010fe](03)  83c404     add esp,+04
>> [00001101](01)  5d         pop ebp
>> [00001102](01)  c3         ret
>> Size in bytes:(0017) [00001102]
>>
>> H: Begin Simulation   Execution Trace Stored at:111fe5
>> [000010f2][00111fd1][00111fd5] 55         push ebp
>> [000010f3][00111fd1][00111fd5] 8bec       mov ebp,esp
>> [000010f5][00111fd1][00111fd5] 8b4508     mov eax,[ebp+08]
>> [000010f8][00111fcd][00000777] 50         push eax      // push 0x777
>> [000010f9][00111fc9][000010fe] e8f4ffffff call 000010f2 // call
>> Infinite_Recursion
>> [000010f2][00111fc5][00111fd1] 55         push ebp
>> [000010f3][00111fc5][00111fd1] 8bec       mov ebp,esp
>> [000010f5][00111fc5][00111fd1] 8b4508     mov eax,[ebp+08]
>> [000010f8][00111fc1][00000777] 50         push eax      // push 0x777
>> [000010f9][00111fbd][000010fe] e8f4ffffff call 000010f2 // call
>> Infinite_Recursion
>> H: Infinite Recursion Detected Simulation Stopped
>>
>> (1) Infinite_Recursion() is called twice in sequence from the same
>> machine address of Infinite_Recursion() .
>> (2) With the same arguments to Infinite_Recursion()
>> (3) With no control flow instructions between the invocation of
>> Infinite_Recursion()  and the call to Infinite_Recursion() from
>> Infinite_Recursion()
>
> For RECURSION, yes. Note that (3) the two mentions of
> "Infinite_Recursion()" specify the SAME function.
>

*Here it is adapted to a more complex case of infinite recursion*
(1) HR is called twice in sequence from the same machine address of PR.
(2) With the same arguments to HR.
(3) With no control flow instructions between the invocation of PR and
the call to HR from PR

*False Positive*
Reporting infinite recursion when there is no infinite recursion.

Do you agree that the above criteria would have no false positives?
(see all the details below).

*H detects that PR is calling HR in infinite recursion*

PR(u32 x)
{ HR(x);
}

HR(u32 y)
{ PR(y);
}

int main()
{ Output((char*)"Input_Halts = ", H(PR, (ptr)0x777));
}

_HR()
[00001042](01) 55 push ebp
[00001043](02) 8bec mov ebp,esp
[00001045](03) 8b4508 mov eax,[ebp+08]
[00001048](01) 50 push eax
[00001049](05) e814000000 call 00001062
[0000104e](03) 83c404 add esp,+04
[00001051](01) 5d pop ebp
[00001052](01) c3 ret
Size in bytes:(0017) [00001052]