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]

_PR()
[00001062](01) 55 push ebp
[00001063](02) 8bec mov ebp,esp
[00001065](03) 8b4508 mov eax,[ebp+08]
[00001068](01) 50 push eax
[00001069](05) e8d4ffffff call 00001042
[0000106e](03) 83c404 add esp,+04
[00001071](01) 5d pop ebp
[00001072](01) c3 ret
Size in bytes:(0017) [00001072]

_main()
[00001082](01) 55 push ebp
[00001083](02) 8bec mov ebp,esp
[00001085](05) 6877070000 push 00000777
[0000108a](05) 6862100000 push 00001062
[0000108f](05) e8fefdffff call 00000e92
[00001094](03) 83c408 add esp,+08
[00001097](01) 50 push eax
[00001098](05) 6863040000 push 00000463
[0000109d](05) e8e0f3ffff call 00000482
[000010a2](03) 83c408 add esp,+08
[000010a5](02) 33c0 xor eax,eax
[000010a7](01) 5d pop ebp
[000010a8](01) c3 ret
Size in bytes:(0039) [000010a8]

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[00001082][00101afb][00000000] 55 push ebp
[00001083][00101afb][00000000] 8bec mov ebp,esp
[00001085][00101af7][00000777] 6877070000 push 00000777 // push 0x777
[0000108a][00101af3][00001062] 6862100000 push 00001062 // push PR
[0000108f][00101aef][00001094] e8fefdffff call 00000e92 // call H

H: Begin Simulation Execution Trace Stored at:111ba7
[00001062][00111b93][00111b97] 55 push ebp // enter PR
[00001063][00111b93][00111b97] 8bec mov ebp,esp
[00001065][00111b93][00111b97] 8b4508 mov eax,[ebp+08]
[00001068][00111b8f][00000777] 50 push eax // push 0x777
[00001069][00111b8b][0000106e] e8d4ffffff call 00001042 // call HR
[00001042][00111b87][00111b93] 55 push ebp
[00001043][00111b87][00111b93] 8bec mov ebp,esp
[00001045][00111b87][00111b93] 8b4508 mov eax,[ebp+08]
[00001048][00111b83][00000777] 50 push eax // push 0x777
[00001049][00111b7f][0000104e] e814000000 call 00001062 // call PR
[00001062][00111b7b][00111b87] 55 push ebp
[00001063][00111b7b][00111b87] 8bec mov ebp,esp
[00001065][00111b7b][00111b87] 8b4508 mov eax,[ebp+08]
[00001068][00111b77][00000777] 50 push eax // push 0x777
[00001069][00111b73][0000106e] e8d4ffffff call 00001042 // call HR
H: Infinite Recursion Detected Simulation Stopped

(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

[00001094][00101afb][00000000] 83c408 add esp,+08
[00001097][00101af7][00000000] 50 push eax
[00001098][00101af3][00000463] 6863040000 push 00000463
[0000109d][00101af3][00000463] e8e0f3ffff call 00000482
Input_Halts = 0
[000010a2][00101afb][00000000] 83c408 add esp,+08
[000010a5][00101afb][00000000] 33c0 xor eax,eax
[000010a7][00101aff][00000018] 5d pop ebp
[000010a8][00101b03][00000000] c3 ret
Number of Instructions Executed(1791) == 27 Pages

--
Copyright 2022 Pete Olcott

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